From: Anton Johansson via qemu development <qemu-devel@nongnu.org>
To: qemu-devel@nongnu.org
Cc: ale@rev.ng, brian.cain@oss.qualcomm.com,
pierrick.bouvier@oss.qualcomm.com, philmd@mailo.com,
Anton Johansson <anjo@rev.ng>
Subject: [PATCH v2 39/50] helper-to-tcg: Add end-to-end tests
Date: Thu, 30 Jul 2026 05:10:13 +0200 [thread overview]
Message-ID: <20260730031025.12926-40-anjo@rev.ng> (raw)
In-Reply-To: <20260730031025.12926-1-anjo@rev.ng>
Introduces simple end-to-end tests, providing input functions covering a
variety of features, and expected outputs for each of test and supported
LLVM version. (Currently reference code for LLVM 15 and 21 is added).
Signed-off-by: Anton Johansson <anjo@rev.ng>
---
subprojects/helper-to-tcg/meson.build | 2 +
.../helper-to-tcg/tests/call-to-declaration.c | 33 ++
.../helper-to-tcg/tests/call-translation.c | 35 ++
subprojects/helper-to-tcg/tests/cpustate.c | 44 ++
.../helper-to-tcg/tests/forward-context.c | 21 +
subprojects/helper-to-tcg/tests/ldst.c | 17 +
subprojects/helper-to-tcg/tests/meson.build | 121 ++++
.../tests/ref/15/call-to-declaration.c | 26 +
.../tests/ref/15/call-translation.c | 28 +
.../helper-to-tcg/tests/ref/15/cpustate.c | 36 ++
.../tests/ref/15/forward-context.c | 30 +
subprojects/helper-to-tcg/tests/ref/15/ldst.c | 21 +
.../helper-to-tcg/tests/ref/15/scalar.c | 21 +
.../tests/ref/15/user-pcrel-jump.c | 33 ++
.../tests/ref/15/vector-layout-f16L.c | 527 ++++++++++++++++++
.../tests/ref/15/vector-layout-f16M.c | 527 ++++++++++++++++++
.../tests/ref/15/vector-layout-f32L.c | 527 ++++++++++++++++++
.../tests/ref/15/vector-layout-f32M.c | 527 ++++++++++++++++++
.../tests/ref/15/vector-layout-f64L.c | 527 ++++++++++++++++++
.../tests/ref/15/vector-layout-f64M.c | 527 ++++++++++++++++++
.../tests/ref/15/vector-layout-f8L.c | 527 ++++++++++++++++++
.../tests/ref/15/vector-layout-f8M.c | 527 ++++++++++++++++++
.../tests/ref/15/vector-layout-t16L.c | 527 ++++++++++++++++++
.../tests/ref/15/vector-layout-t16M.c | 527 ++++++++++++++++++
.../tests/ref/15/vector-layout-t32L.c | 527 ++++++++++++++++++
.../tests/ref/15/vector-layout-t32M.c | 527 ++++++++++++++++++
.../tests/ref/15/vector-layout-t64L.c | 527 ++++++++++++++++++
.../tests/ref/15/vector-layout-t64M.c | 527 ++++++++++++++++++
.../tests/ref/15/vector-layout-t8L.c | 527 ++++++++++++++++++
.../tests/ref/15/vector-layout-t8M.c | 527 ++++++++++++++++++
.../helper-to-tcg/tests/ref/15/vector.c | 31 ++
.../tests/ref/21/call-to-declaration.c | 26 +
.../tests/ref/21/call-translation.c | 28 +
.../helper-to-tcg/tests/ref/21/cpustate.c | 36 ++
.../tests/ref/21/forward-context.c | 30 +
subprojects/helper-to-tcg/tests/ref/21/ldst.c | 21 +
.../helper-to-tcg/tests/ref/21/scalar.c | 21 +
.../tests/ref/21/user-pcrel-jump.c | 33 ++
.../tests/ref/21/vector-layout-f16L.c | 527 ++++++++++++++++++
.../tests/ref/21/vector-layout-f16M.c | 527 ++++++++++++++++++
.../tests/ref/21/vector-layout-f32L.c | 527 ++++++++++++++++++
.../tests/ref/21/vector-layout-f32M.c | 527 ++++++++++++++++++
.../tests/ref/21/vector-layout-f64L.c | 527 ++++++++++++++++++
.../tests/ref/21/vector-layout-f64M.c | 527 ++++++++++++++++++
.../tests/ref/21/vector-layout-f8L.c | 527 ++++++++++++++++++
.../tests/ref/21/vector-layout-f8M.c | 527 ++++++++++++++++++
.../tests/ref/21/vector-layout-t16L.c | 527 ++++++++++++++++++
.../tests/ref/21/vector-layout-t16M.c | 527 ++++++++++++++++++
.../tests/ref/21/vector-layout-t32L.c | 527 ++++++++++++++++++
.../tests/ref/21/vector-layout-t32M.c | 527 ++++++++++++++++++
.../tests/ref/21/vector-layout-t64L.c | 527 ++++++++++++++++++
.../tests/ref/21/vector-layout-t64M.c | 527 ++++++++++++++++++
.../tests/ref/21/vector-layout-t8L.c | 527 ++++++++++++++++++
.../tests/ref/21/vector-layout-t8M.c | 527 ++++++++++++++++++
.../helper-to-tcg/tests/ref/21/vector.c | 31 ++
subprojects/helper-to-tcg/tests/scalar.c | 15 +
.../helper-to-tcg/tests/tcg-global-mappings.h | 118 ++++
.../helper-to-tcg/tests/user-pcrel-jump.c | 28 +
.../helper-to-tcg/tests/vector-layout.c | 51 ++
subprojects/helper-to-tcg/tests/vector.c | 34 ++
60 files changed, 17835 insertions(+)
create mode 100644 subprojects/helper-to-tcg/tests/call-to-declaration.c
create mode 100644 subprojects/helper-to-tcg/tests/call-translation.c
create mode 100644 subprojects/helper-to-tcg/tests/cpustate.c
create mode 100644 subprojects/helper-to-tcg/tests/forward-context.c
create mode 100644 subprojects/helper-to-tcg/tests/ldst.c
create mode 100644 subprojects/helper-to-tcg/tests/meson.build
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/call-to-declaration.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/call-translation.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/cpustate.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/forward-context.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/ldst.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/scalar.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/user-pcrel-jump.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector-layout-f16L.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector-layout-f16M.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector-layout-f32L.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector-layout-f32M.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector-layout-f64L.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector-layout-f64M.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector-layout-f8L.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector-layout-f8M.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector-layout-t16L.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector-layout-t16M.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector-layout-t32L.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector-layout-t32M.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector-layout-t64L.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector-layout-t64M.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector-layout-t8L.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector-layout-t8M.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/15/vector.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/call-to-declaration.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/call-translation.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/cpustate.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/forward-context.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/ldst.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/scalar.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/user-pcrel-jump.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector-layout-f16L.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector-layout-f16M.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector-layout-f32L.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector-layout-f32M.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector-layout-f64L.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector-layout-f64M.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector-layout-f8L.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector-layout-f8M.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector-layout-t16L.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector-layout-t16M.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector-layout-t32L.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector-layout-t32M.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector-layout-t64L.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector-layout-t64M.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector-layout-t8L.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector-layout-t8M.c
create mode 100644 subprojects/helper-to-tcg/tests/ref/21/vector.c
create mode 100644 subprojects/helper-to-tcg/tests/scalar.c
create mode 100644 subprojects/helper-to-tcg/tests/tcg-global-mappings.h
create mode 100644 subprojects/helper-to-tcg/tests/user-pcrel-jump.c
create mode 100644 subprojects/helper-to-tcg/tests/vector-layout.c
create mode 100644 subprojects/helper-to-tcg/tests/vector.c
diff --git a/subprojects/helper-to-tcg/meson.build b/subprojects/helper-to-tcg/meson.build
index 413d7ad8fa..d903b560d1 100644
--- a/subprojects/helper-to-tcg/meson.build
+++ b/subprojects/helper-to-tcg/meson.build
@@ -82,3 +82,5 @@ pipeline = executable('helper-to-tcg', sources,
include_directories: ['include'] + [incdir],
link_args: [ldflags] + [libs] + [syslibs],
cpp_args: cpp_args)
+
+subdir('tests')
diff --git a/subprojects/helper-to-tcg/tests/call-to-declaration.c b/subprojects/helper-to-tcg/tests/call-to-declaration.c
new file mode 100644
index 0000000000..d0fc583270
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/call-to-declaration.c
@@ -0,0 +1,33 @@
+/*
+ * Test translation of calls to declration
+ *
+ * (experimental)
+ */
+
+#define ANNOTATE(str) __attribute__((annotate(str)))
+
+int fdecl0(int a);
+
+ANNOTATE("helper-to-tcg")
+int f0(int cond, int b) {
+ return fdecl0(b);
+}
+
+ANNOTATE("immediate: 0")
+int fdecl1(int a);
+
+ANNOTATE("helper-to-tcg")
+ANNOTATE("immediate: 1")
+int f1(int cond, int b) {
+ return fdecl1(b);
+}
+
+ANNOTATE("returns-immediate")
+ANNOTATE("immediate: 0")
+int fdecl2(int a);
+
+ANNOTATE("helper-to-tcg")
+ANNOTATE("immediate: 0")
+int f2(int b) {
+ return fdecl2(b);
+}
diff --git a/subprojects/helper-to-tcg/tests/call-translation.c b/subprojects/helper-to-tcg/tests/call-translation.c
new file mode 100644
index 0000000000..fc3ca68755
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/call-translation.c
@@ -0,0 +1,35 @@
+/*
+ * Test translation of dependent functions.
+ *
+ * This test will be ran without --translate-all-helpers, meaning we have to
+ * manually mark them for translation.
+ */
+
+#define ANNOTATE(str) __attribute__((annotate(str)))
+
+/*
+ * Only inner0 is marked for translation, outer0 will be skipped.
+ */
+ANNOTATE("helper-to-tcg")
+int inner0(int a) { return a + 5; }
+
+int outer0(int cond, int b) {
+ if (cond) {
+ return inner0(b);
+ }
+ return 0;
+}
+
+/*
+ * Both inner1 and outer1 will be translated since outer1 is marked for
+ * translation and depends on inner1.
+ */
+int inner1(int a) { return a + 5; }
+
+ANNOTATE("helper-to-tcg")
+int outer1(int cond, int b) {
+ if (cond) {
+ return inner1(b);
+ }
+ return 0;
+}
diff --git a/subprojects/helper-to-tcg/tests/cpustate.c b/subprojects/helper-to-tcg/tests/cpustate.c
new file mode 100644
index 0000000000..61ff6b28cf
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/cpustate.c
@@ -0,0 +1,44 @@
+#include <stddef.h>
+#include <stdint.h>
+
+#define stringify(str) #str
+
+#include "tcg-global-mappings.h"
+
+typedef struct SpecialData {
+ uint32_t a;
+ uint32_t unmapped_field;
+} SpecialData;
+
+typedef struct CPUArchState {
+ uint32_t regs[32];
+ uint32_t unmapped_field;
+ SpecialData data[8];
+ uint32_t mapped_field;
+} CPUArchState;
+
+/* Dummy struct, in QEMU this would correspond to TCGv_i32 in tcg.h */
+/* Global TCGv's representing CPU state */
+struct{} tcg_regs[32];
+struct{} tcg_a[8];
+struct{} tcg_field;
+
+cpu_tcg_mapping mappings[] = {
+ CPU_TCG_MAP_ARRAY(CPUArchState, tcg_regs, regs, NULL),
+ CPU_TCG_MAP_ARRAY_OF_STRUCTS(CPUArchState, tcg_a, data, a, NULL),
+ CPU_TCG_MAP(CPUArchState, tcg_field, mapped_field),
+};
+
+__attribute__((annotate("immediate: 1"))) uint32_t helper_reg(CPUArchState *env,
+ uint32_t i) {
+ return env->regs[i];
+}
+
+__attribute__((annotate("immediate: 1"))) uint32_t
+helper_data_a(CPUArchState *env, uint32_t i) {
+ return env->data[i].a;
+}
+
+uint32_t helper_single_mapped(CPUArchState *env) { return env->mapped_field; }
+
+uint32_t helper_unmapped(CPUArchState *env) { return env->unmapped_field; }
diff --git a/subprojects/helper-to-tcg/tests/forward-context.c b/subprojects/helper-to-tcg/tests/forward-context.c
new file mode 100644
index 0000000000..4eb55b7e3d
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/forward-context.c
@@ -0,0 +1,21 @@
+/*
+ * Test translation of calls to declration
+ *
+ * This test will be ran without --translate-all-helpers, meaning we have to
+ * manually mark them for translation.
+ */
+
+#define ANNOTATE(str) __attribute__((annotate(str)))
+
+ANNOTATE("immediate: 0")
+int fdecl0(int a);
+
+ANNOTATE("helper-to-tcg")
+int f0(int a, int off) {
+ return a + fdecl0(off);
+}
+
+ANNOTATE("helper-to-tcg")
+int f1(int a) {
+ return f0(a,a) + f0(-a,-a);
+}
diff --git a/subprojects/helper-to-tcg/tests/ldst.c b/subprojects/helper-to-tcg/tests/ldst.c
new file mode 100644
index 0000000000..44d32d0875
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ldst.c
@@ -0,0 +1,17 @@
+#include <stdint.h>
+
+/* Opaque CPU state type, will be mapped to tcg_env */
+struct CPUArchState;
+typedef struct CPUArchState CPUArchState;
+
+/* Prototype of QEMU helper guest load/store functions, see exec/cpu_ldst.h */
+uint32_t cpu_ldub_data(CPUArchState *, uint32_t ptr);
+void cpu_stb_data(CPUArchState *, uint32_t ptr, uint32_t data);
+
+uint32_t helper_ld8(CPUArchState *env, uint32_t addr) {
+ return cpu_ldub_data(env, addr);
+}
+
+void helper_st8(CPUArchState *env, uint32_t addr, uint32_t data) {
+ return cpu_stb_data(env, addr, data);
+}
diff --git a/subprojects/helper-to-tcg/tests/meson.build b/subprojects/helper-to-tcg/tests/meson.build
new file mode 100644
index 0000000000..b2e53550eb
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/meson.build
@@ -0,0 +1,121 @@
+fs = import('fs')
+
+sources = {
+ 'scalar.c' : ['--translate-all-helpers'],
+ 'ldst.c' : [
+ '--translate-all-helpers',
+ '--mmu-index-function=tb_mmu_index',
+ ],
+ 'cpustate.c' : [
+ '--translate-all-helpers',
+ '--tcg-global-mappings=mappings',
+ ],
+ 'vector.c' : [
+ '--translate-all-helpers',
+ '--temp-vector-block=vmem',
+ ],
+ 'call-translation.c' : [],
+ 'call-to-declaration.c' : [
+ '--allow-decl-call',
+ ],
+ 'forward-context.c' : [
+ '--allow-decl-call',
+ '--forward-context',
+ ],
+ 'user-pcrel-jump.c' : [
+ '--allow-decl-call',
+ '--user-pcrel-branch-func=target_pcrel_jump',
+ '--user-pcrel-branch-conditional-func=target_pcrel_jump_cond',
+ '--user-pcrel-branch-fallthrough-func=target_pcrel_jump_fall',
+ ],
+}
+
+sources_vector_layout = {
+ 'vector-layout.c' : [],
+}
+
+diff = find_program('diff')
+
+foreach file : sources.keys()
+ extra_flags = sources.get(file)
+
+ name = file.split('.')[0]
+ name_ll = name + '.ll'
+
+ ll = custom_target(name_ll,
+ input: files(file),
+ output: name_ll,
+ command: [clang, '-O0', '-Xclang', '-disable-O0-optnone',
+ '-g', '-S', '-emit-llvm', '-o', '@OUTPUT@', '@INPUT@']
+ )
+
+ output_prefix = join_paths(meson.current_build_dir(), name)
+ flags = [ll,
+ '--output-enabled=' + output_prefix + '-enabled',
+ '--output-source=' + output_prefix + '.c',
+ '--output-header=' + output_prefix + '.h',
+ '--mmu-index-function=tb_mmu_index',
+ '--tcg-global-mappings=mappings']
+ flags += extra_flags
+
+ runtest = name + '-run-' + version_major.to_string()
+ test(runtest,
+ pipeline,
+ depends: ll,
+ priority: 2,
+ args: flags,
+ suite: 'helper-to-tcg')
+
+ ref = join_paths(meson.current_source_dir(), 'ref', version_major.to_string(), name + '.c')
+ if fs.exists(ref)
+ test(name + '-diff-' + version_major.to_string(),
+ diff,
+ priority: 1,
+ args: ['-u', output_prefix + '.c', ref ], suite: 'helper-to-tcg')
+ endif
+endforeach
+
+# Build and compare tests against references again, but force different vector layouts.
+foreach file : sources_vector_layout.keys()
+ extra_flags = sources_vector_layout.get(file)
+ name = file.split('.')[0]
+ name_ll = name + '.ll'
+
+ ll = custom_target(name_ll,
+ input: files(file),
+ output: name_ll,
+ command: [clang, '-O0', '-Xclang', '-disable-O0-optnone',
+ '-g', '-S', '-emit-llvm', '-o', '@OUTPUT@', '@INPUT@']
+ )
+
+ foreach size : [8,16,32,64]
+ foreach lane0 : ['LeastSignificant', 'MostSignificant']
+ foreach big_endian: ['true', 'false']
+ test_str = big_endian[0] + size.to_string() + lane0[0]
+ output_prefix = join_paths(meson.current_build_dir(), name + '-' + test_str)
+ runtest = name + '-run-' + test_str
+ test(runtest,
+ pipeline,
+ depends: ll,
+ priority: 2,
+ args: [ll,
+ '--output-enabled=' + output_prefix + '-enabled',
+ '--output-source=' + output_prefix + '.c',
+ '--output-header=' + output_prefix + '.h',
+ '--translate-all-helpers',
+ '--vec-force-big-endian=' + big_endian,
+ '--vec-block-bytes=' + size.to_string(),
+ '--vec-lane-0=' + lane0,
+ ] + extra_flags,
+ suite: 'helper-to-tcg')
+ ref = join_paths(meson.current_source_dir(), 'ref', version_major.to_string(), name + '-' + test_str + '.c')
+ if fs.exists(ref)
+ test(name + '-diff-' + test_str,
+ diff,
+ priority: 1,
+ args: ['-u', output_prefix + '.c', ref ], suite: 'helper-to-tcg')
+ endif
+ endforeach
+ endforeach
+ endforeach
+endforeach
diff --git a/subprojects/helper-to-tcg/tests/ref/15/call-to-declaration.c b/subprojects/helper-to-tcg/tests/ref/15/call-to-declaration.c
new file mode 100644
index 0000000000..e778d8785d
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/call-to-declaration.c
@@ -0,0 +1,26 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "call-to-declaration.h"
+
+// i32 f0
+void emit_f0(TCGv_i32 tmp2, TCGv_i32 tmp0, TCGv_i32 b) {
+tmp2 = fdecl0(b);
+}
+
+// i32 f1
+void emit_f1(TCGv_i32 tmp2, TCGv_i32 tmp0, uint32_t b) {
+tmp2 = fdecl1(tcg_constant_i32(b));
+}
+
+// i32 f2
+void emit_f2(TCGv_i32 tmp1, uint32_t b) {
+tmp1 = fdecl2(tcg_constant_i32(b));
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/call-translation.c b/subprojects/helper-to-tcg/tests/ref/15/call-translation.c
new file mode 100644
index 0000000000..406f48953e
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/call-translation.c
@@ -0,0 +1,28 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "call-translation.h"
+
+// i32 inner0
+void emit_inner0(TCGv_i32 tmp2, TCGv_i32 a) {
+tcg_gen_add_i32(tmp2, a, tcg_constant_i32(5));
+}
+
+// i32 inner1
+void emit_inner1(TCGv_i32 tmp2, TCGv_i32 a) {
+tcg_gen_add_i32(tmp2, a, tcg_constant_i32(5));
+}
+
+// i32 outer1
+void emit_outer1(TCGv_i32 tmp5, TCGv_i32 cond, TCGv_i32 b) {
+TCGv_i32 tmp6 = tcg_temp_new_i32();
+tcg_gen_add_i32(tmp6, b, tcg_constant_i32(5));
+tcg_gen_movcond_i32(TCG_COND_EQ, tmp5, cond, tcg_constant_i32(0), tcg_constant_i32(0), tmp6);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/cpustate.c b/subprojects/helper-to-tcg/tests/ref/15/cpustate.c
new file mode 100644
index 0000000000..e022a14d0c
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/cpustate.c
@@ -0,0 +1,36 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "cpustate.h"
+
+extern TCGv_i32 tcg_regs[32];
+extern TCGv_i32 tcg_a[8];
+extern TCGv_i32 tcg_field;
+// i32 helper_reg
+void emit_reg(TCGv_i32 tmp5, TCGv_ptr env, uint32_t i) {
+tcg_gen_mov_i32(tmp5, tcg_regs[((uint64_t) (uint32_t) i)]);
+}
+
+// i32 helper_data_a
+void emit_data_a(TCGv_i32 tmp6, TCGv_ptr env, uint32_t i) {
+tcg_gen_mov_i32(tmp6, tcg_a[((uint64_t) (uint32_t) i)]);
+}
+
+// i32 helper_single_mapped
+void emit_single_mapped(TCGv_i32 tmp4, TCGv_ptr env) {
+tcg_gen_mov_i32(tmp4, tcg_field);
+}
+
+// i32 helper_unmapped
+void emit_unmapped(TCGv_i32 tmp2, TCGv_ptr env) {
+TCGv_ptr ptr3 = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(ptr3, env, 128ull);
+tcg_gen_ld_i32(tmp2, ptr3, 0);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/forward-context.c b/subprojects/helper-to-tcg/tests/ref/15/forward-context.c
new file mode 100644
index 0000000000..a1c0e5f37a
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/forward-context.c
@@ -0,0 +1,30 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "translate.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "forward-context.h"
+
+#include "translate.h"
+// i32 f0
+void emit_f0(DisasContext *ctx, TCGv_i32 tmp2, TCGv_i32 a, TCGv_i32 off) {
+TCGv_i32 tmp3 = tcg_temp_new_i32();
+tmp3 = fdecl0(ctx, off);
+tcg_gen_add_i32(tmp2, tmp3, a);
+}
+
+// i32 f1
+void emit_f1(DisasContext *ctx, TCGv_i32 tmp2, TCGv_i32 a) {
+TCGv_i32 tmp4 = tcg_temp_new_i32();
+tmp4 = fdecl0(ctx, a);
+tcg_gen_sub_i32(tmp2, tcg_constant_i32(0), a);
+TCGv_i32 tmp3 = tcg_temp_new_i32();
+tmp3 = fdecl0(ctx, tmp2);
+tcg_gen_add_i32(tmp2, tmp3, tmp4);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/ldst.c b/subprojects/helper-to-tcg/tests/ref/15/ldst.c
new file mode 100644
index 0000000000..5710b0b285
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/ldst.c
@@ -0,0 +1,21 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "ldst.h"
+
+// i32 helper_ld8
+void emit_ld8(TCGv_i32 tmp4, TCGv_ptr env, TCGv_i32 addr) {
+tcg_gen_qemu_ld_i32(tmp4, addr, tb_mmu_index(tcg_ctx->gen_tb->flags), MO_8);
+}
+
+// void helper_st8
+void emit_st8(TCGv_ptr env, TCGv_i32 addr, TCGv_i32 data) {
+tcg_gen_qemu_st_i32(data, addr, tb_mmu_index(tcg_ctx->gen_tb->flags), MO_8);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/scalar.c b/subprojects/helper-to-tcg/tests/ref/15/scalar.c
new file mode 100644
index 0000000000..50fe4307c0
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/scalar.c
@@ -0,0 +1,21 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "scalar.h"
+
+// i32 helper_add
+void emit_add(TCGv_i32 tmp2, TCGv_i32 a, TCGv_i32 b) {
+tcg_gen_add_i32(tmp2, b, a);
+}
+
+// i32 helper_cmov
+void emit_cmov(TCGv_i32 tmp5, TCGv_i32 c0, TCGv_i32 c1, TCGv_i32 a, TCGv_i32 b) {
+tcg_gen_movcond_i32(TCG_COND_LTU, tmp5, c0, c1, a, b);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/user-pcrel-jump.c b/subprojects/helper-to-tcg/tests/ref/15/user-pcrel-jump.c
new file mode 100644
index 0000000000..68e6c5d441
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/user-pcrel-jump.c
@@ -0,0 +1,33 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "user-pcrel-jump.h"
+
+// void prcel_jump
+void emit_prcel_jump(TCGv_i32 off) {
+TCGv_i32 ea = tcg_temp_new_i32();
+tcg_gen_shl_i32(ea, off, tcg_constant_i32(2));
+tcg_gen_or_i32(ea, ea, tcg_constant_i32(3));
+target_pcrel_jump(ea);
+}
+
+// void prcel_condjump
+void emit_prcel_condjump(TCGv_i32 cond, TCGv_i32 off) {
+TCGLabel * label8 = gen_new_label();
+TCGLabel * label9 = gen_new_label();
+tcg_gen_brcondi_i32(TCG_COND_EQ, cond, 0, label8);
+gen_set_label(label9);
+TCGv_i32 ea = tcg_temp_new_i32();
+tcg_gen_shl_i32(ea, off, tcg_constant_i32(2));
+tcg_gen_or_i32(ea, ea, tcg_constant_i32(3));
+target_pcrel_jump(ea);
+tcg_gen_br(label8);
+gen_set_label(label8);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f16L.c b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f16L.c
new file mode 100644
index 0000000000..146c940bd4
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f16L.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-f16L.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 2;
+const size_t ci = i % 8;
+const size_t bc = c % 2;
+return 16 * b + 8 * bc + ci;
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 2;
+const size_t ci = i % 4;
+const size_t bc = c % 2;
+return 8 * b + 4 * bc + ci;
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 2;
+const size_t ci = i % 2;
+const size_t bc = c % 2;
+return 4 * b + 2 * bc + ci;
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 2;
+const size_t ci = i % 1;
+const size_t bc = c % 2;
+return 2 * b + 1 * bc + ci;
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x807060504030201, 0x100F0E0D0C0B0A09, 0x1817161514131211, 0x201F1E1D1C1B1A19};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x807060504030201);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f16M.c b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f16M.c
new file mode 100644
index 0000000000..76cff20bee
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f16M.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-f16M.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 2;
+const size_t ci = i % 8;
+const size_t bc = c % 2;
+return 16 * b + 8 * (1 - bc) + (7 - ci);
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 2;
+const size_t ci = i % 4;
+const size_t bc = c % 2;
+return 8 * b + 4 * (1 - bc) + (3 - ci);
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 2;
+const size_t ci = i % 2;
+const size_t bc = c % 2;
+return 4 * b + 2 * (1 - bc) + (1 - ci);
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 2;
+const size_t ci = i % 1;
+const size_t bc = c % 2;
+return 2 * b + 1 * (1 - bc) + (0 - ci);
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x90A0B0C0D0E0F10, 0x102030405060708, 0x191A1B1C1D1E1F20, 0x1112131415161718};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x102030405060708);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f32L.c b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f32L.c
new file mode 100644
index 0000000000..8515b3488e
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f32L.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-f32L.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 4;
+const size_t ci = i % 8;
+const size_t bc = c % 4;
+return 32 * b + 8 * bc + ci;
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 4;
+const size_t ci = i % 4;
+const size_t bc = c % 4;
+return 16 * b + 4 * bc + ci;
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 4;
+const size_t ci = i % 2;
+const size_t bc = c % 4;
+return 8 * b + 2 * bc + ci;
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 4;
+const size_t ci = i % 1;
+const size_t bc = c % 4;
+return 4 * b + 1 * bc + ci;
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x807060504030201, 0x100F0E0D0C0B0A09, 0x1817161514131211, 0x201F1E1D1C1B1A19};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x807060504030201);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f32M.c b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f32M.c
new file mode 100644
index 0000000000..41067c4c62
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f32M.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-f32M.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 4;
+const size_t ci = i % 8;
+const size_t bc = c % 4;
+return 32 * b + 8 * (3 - bc) + (7 - ci);
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 4;
+const size_t ci = i % 4;
+const size_t bc = c % 4;
+return 16 * b + 4 * (3 - bc) + (3 - ci);
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 4;
+const size_t ci = i % 2;
+const size_t bc = c % 4;
+return 8 * b + 2 * (3 - bc) + (1 - ci);
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 4;
+const size_t ci = i % 1;
+const size_t bc = c % 4;
+return 4 * b + 1 * (3 - bc) + (0 - ci);
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x191A1B1C1D1E1F20, 0x1112131415161718, 0x90A0B0C0D0E0F10, 0x102030405060708};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x102030405060708);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f64L.c b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f64L.c
new file mode 100644
index 0000000000..d8e660be8b
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f64L.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-f64L.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 8;
+const size_t ci = i % 8;
+const size_t bc = c % 8;
+return 64 * b + 8 * bc + ci;
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 8;
+const size_t ci = i % 4;
+const size_t bc = c % 8;
+return 32 * b + 4 * bc + ci;
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 8;
+const size_t ci = i % 2;
+const size_t bc = c % 8;
+return 16 * b + 2 * bc + ci;
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 8;
+const size_t ci = i % 1;
+const size_t bc = c % 8;
+return 8 * b + 1 * bc + ci;
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x807060504030201, 0x100F0E0D0C0B0A09, 0x1817161514131211, 0x201F1E1D1C1B1A19};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x807060504030201);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f64M.c b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f64M.c
new file mode 100644
index 0000000000..facfe730c1
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f64M.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-f64M.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 8;
+const size_t ci = i % 8;
+const size_t bc = c % 8;
+return 64 * b + 8 * (7 - bc) + (7 - ci);
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 8;
+const size_t ci = i % 4;
+const size_t bc = c % 8;
+return 32 * b + 4 * (7 - bc) + (3 - ci);
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 8;
+const size_t ci = i % 2;
+const size_t bc = c % 8;
+return 16 * b + 2 * (7 - bc) + (1 - ci);
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 8;
+const size_t ci = i % 1;
+const size_t bc = c % 8;
+return 8 * b + 1 * (7 - bc) + (0 - ci);
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x191A1B1C1D1E1F20, 0x1112131415161718, 0x90A0B0C0D0E0F10, 0x102030405060708};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x102030405060708);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f8L.c b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f8L.c
new file mode 100644
index 0000000000..98f4d0a584
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f8L.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-f8L.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 1;
+const size_t ci = i % 8;
+const size_t bc = c % 1;
+return 8 * b + 8 * bc + ci;
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 1;
+const size_t ci = i % 4;
+const size_t bc = c % 1;
+return 4 * b + 4 * bc + ci;
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 1;
+const size_t ci = i % 2;
+const size_t bc = c % 1;
+return 2 * b + 2 * bc + ci;
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 1;
+const size_t ci = i % 1;
+const size_t bc = c % 1;
+return 1 * b + 1 * bc + ci;
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x807060504030201, 0x100F0E0D0C0B0A09, 0x1817161514131211, 0x201F1E1D1C1B1A19};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x807060504030201);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f8M.c b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f8M.c
new file mode 100644
index 0000000000..a768efc628
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-f8M.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-f8M.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 1;
+const size_t ci = i % 8;
+const size_t bc = c % 1;
+return 8 * b + 8 * (0 - bc) + (7 - ci);
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 1;
+const size_t ci = i % 4;
+const size_t bc = c % 1;
+return 4 * b + 4 * (0 - bc) + (3 - ci);
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 1;
+const size_t ci = i % 2;
+const size_t bc = c % 1;
+return 2 * b + 2 * (0 - bc) + (1 - ci);
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 1;
+const size_t ci = i % 1;
+const size_t bc = c % 1;
+return 1 * b + 1 * (0 - bc) + (0 - ci);
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x102030405060708, 0x90A0B0C0D0E0F10, 0x1112131415161718, 0x191A1B1C1D1E1F20};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x102030405060708);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t16L.c b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t16L.c
new file mode 100644
index 0000000000..ca6944fa92
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t16L.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-t16L.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 2;
+const size_t ci = i % 8;
+const size_t bc = c % 2;
+return 16 * b + 8 * (1 - bc) + (7 - ci);
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 2;
+const size_t ci = i % 4;
+const size_t bc = c % 2;
+return 8 * b + 4 * (1 - bc) + (3 - ci);
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 2;
+const size_t ci = i % 2;
+const size_t bc = c % 2;
+return 4 * b + 2 * (1 - bc) + (1 - ci);
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 2;
+const size_t ci = i % 1;
+const size_t bc = c % 2;
+return 2 * b + 1 * (1 - bc) + (0 - ci);
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x100F0E0D0C0B0A09, 0x807060504030201, 0x201F1E1D1C1B1A19, 0x1817161514131211};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x807060504030201);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t16M.c b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t16M.c
new file mode 100644
index 0000000000..a4e0ca054f
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t16M.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-t16M.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 2;
+const size_t ci = i % 8;
+const size_t bc = c % 2;
+return 16 * b + 8 * bc + ci;
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 2;
+const size_t ci = i % 4;
+const size_t bc = c % 2;
+return 8 * b + 4 * bc + ci;
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 2;
+const size_t ci = i % 2;
+const size_t bc = c % 2;
+return 4 * b + 2 * bc + ci;
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 2;
+const size_t ci = i % 1;
+const size_t bc = c % 2;
+return 2 * b + 1 * bc + ci;
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x102030405060708, 0x90A0B0C0D0E0F10, 0x1112131415161718, 0x191A1B1C1D1E1F20};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x102030405060708);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t32L.c b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t32L.c
new file mode 100644
index 0000000000..b142d9b8ce
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t32L.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-t32L.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 4;
+const size_t ci = i % 8;
+const size_t bc = c % 4;
+return 32 * b + 8 * (3 - bc) + (7 - ci);
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 4;
+const size_t ci = i % 4;
+const size_t bc = c % 4;
+return 16 * b + 4 * (3 - bc) + (3 - ci);
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 4;
+const size_t ci = i % 2;
+const size_t bc = c % 4;
+return 8 * b + 2 * (3 - bc) + (1 - ci);
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 4;
+const size_t ci = i % 1;
+const size_t bc = c % 4;
+return 4 * b + 1 * (3 - bc) + (0 - ci);
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x201F1E1D1C1B1A19, 0x1817161514131211, 0x100F0E0D0C0B0A09, 0x807060504030201};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x807060504030201);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t32M.c b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t32M.c
new file mode 100644
index 0000000000..109ab19c39
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t32M.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-t32M.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 4;
+const size_t ci = i % 8;
+const size_t bc = c % 4;
+return 32 * b + 8 * bc + ci;
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 4;
+const size_t ci = i % 4;
+const size_t bc = c % 4;
+return 16 * b + 4 * bc + ci;
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 4;
+const size_t ci = i % 2;
+const size_t bc = c % 4;
+return 8 * b + 2 * bc + ci;
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 4;
+const size_t ci = i % 1;
+const size_t bc = c % 4;
+return 4 * b + 1 * bc + ci;
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x102030405060708, 0x90A0B0C0D0E0F10, 0x1112131415161718, 0x191A1B1C1D1E1F20};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x102030405060708);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t64L.c b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t64L.c
new file mode 100644
index 0000000000..4f325caa75
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t64L.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-t64L.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 8;
+const size_t ci = i % 8;
+const size_t bc = c % 8;
+return 64 * b + 8 * (7 - bc) + (7 - ci);
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 8;
+const size_t ci = i % 4;
+const size_t bc = c % 8;
+return 32 * b + 4 * (7 - bc) + (3 - ci);
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 8;
+const size_t ci = i % 2;
+const size_t bc = c % 8;
+return 16 * b + 2 * (7 - bc) + (1 - ci);
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 8;
+const size_t ci = i % 1;
+const size_t bc = c % 8;
+return 8 * b + 1 * (7 - bc) + (0 - ci);
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x201F1E1D1C1B1A19, 0x1817161514131211, 0x100F0E0D0C0B0A09, 0x807060504030201};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x807060504030201);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t64M.c b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t64M.c
new file mode 100644
index 0000000000..766a827128
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t64M.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-t64M.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 8;
+const size_t ci = i % 8;
+const size_t bc = c % 8;
+return 64 * b + 8 * bc + ci;
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 8;
+const size_t ci = i % 4;
+const size_t bc = c % 8;
+return 32 * b + 4 * bc + ci;
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 8;
+const size_t ci = i % 2;
+const size_t bc = c % 8;
+return 16 * b + 2 * bc + ci;
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 8;
+const size_t ci = i % 1;
+const size_t bc = c % 8;
+return 8 * b + 1 * bc + ci;
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x102030405060708, 0x90A0B0C0D0E0F10, 0x1112131415161718, 0x191A1B1C1D1E1F20};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x102030405060708);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t8L.c b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t8L.c
new file mode 100644
index 0000000000..18feb85fad
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t8L.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-t8L.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 1;
+const size_t ci = i % 8;
+const size_t bc = c % 1;
+return 8 * b + 8 * (0 - bc) + (7 - ci);
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 1;
+const size_t ci = i % 4;
+const size_t bc = c % 1;
+return 4 * b + 4 * (0 - bc) + (3 - ci);
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 1;
+const size_t ci = i % 2;
+const size_t bc = c % 1;
+return 2 * b + 2 * (0 - bc) + (1 - ci);
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 1;
+const size_t ci = i % 1;
+const size_t bc = c % 1;
+return 1 * b + 1 * (0 - bc) + (0 - ci);
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x807060504030201, 0x100F0E0D0C0B0A09, 0x1817161514131211, 0x201F1E1D1C1B1A19};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x807060504030201);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t8M.c b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t8M.c
new file mode 100644
index 0000000000..97ebe17e91
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector-layout-t8M.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-t8M.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 1;
+const size_t ci = i % 8;
+const size_t bc = c % 1;
+return 8 * b + 8 * bc + ci;
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 1;
+const size_t ci = i % 4;
+const size_t bc = c % 1;
+return 4 * b + 4 * bc + ci;
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 1;
+const size_t ci = i % 2;
+const size_t bc = c % 1;
+return 2 * b + 2 * bc + ci;
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 1;
+const size_t ci = i % 1;
+const size_t bc = c % 1;
+return 1 * b + 1 * bc + ci;
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x102030405060708, 0x90A0B0C0D0E0F10, 0x1112131415161718, 0x191A1B1C1D1E1F20};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x102030405060708);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/15/vector.c b/subprojects/helper-to-tcg/tests/ref/15/vector.c
new file mode 100644
index 0000000000..deeec8e8ab
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/15/vector.c
@@ -0,0 +1,31 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector.h"
+
+// void helper_vec_splat_reg
+void emit_vec_splat_reg(intptr_t d, TCGv_i32 imm) {
+tcg_gen_gvec_dup_i32(MO_8, d, 32ull, 32ull, imm);
+}
+
+// void helper_vec_splat_imm
+void emit_vec_splat_imm(intptr_t d, uint8_t imm) {
+tcg_gen_gvec_dup_imm(MO_8, d, 32ull, 32ull, imm);
+}
+
+// void helper_vec_add
+void emit_vec_add(intptr_t d, intptr_t a, intptr_t b) {
+tcg_gen_gvec_add(MO_8, d, b, a, 32, 32);
+}
+
+// void helper_vec_add32
+void emit_vec_add32(intptr_t d, intptr_t a, intptr_t b) {
+tcg_gen_gvec_add(MO_32, d, b, a, 128, 128);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/call-to-declaration.c b/subprojects/helper-to-tcg/tests/ref/21/call-to-declaration.c
new file mode 100644
index 0000000000..4b445ec8b1
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/call-to-declaration.c
@@ -0,0 +1,26 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "call-to-declaration.h"
+
+// i32 f0
+void emit_f0(TCGv_i32 tmp2, TCGv_i32 tmp0, TCGv_i32 b) {
+tmp2 = fdecl0(b);
+}
+
+// i32 f1
+void emit_f1(TCGv_i32 tmp2, TCGv_i32 tmp0, uint32_t b) {
+tmp2 = fdecl1(b);
+}
+
+// i32 f2
+void emit_f2(TCGv_i32 tmp2, uint32_t b) {
+tcg_gen_movi_i32(tmp2, imm1);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/call-translation.c b/subprojects/helper-to-tcg/tests/ref/21/call-translation.c
new file mode 100644
index 0000000000..406f48953e
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/call-translation.c
@@ -0,0 +1,28 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "call-translation.h"
+
+// i32 inner0
+void emit_inner0(TCGv_i32 tmp2, TCGv_i32 a) {
+tcg_gen_add_i32(tmp2, a, tcg_constant_i32(5));
+}
+
+// i32 inner1
+void emit_inner1(TCGv_i32 tmp2, TCGv_i32 a) {
+tcg_gen_add_i32(tmp2, a, tcg_constant_i32(5));
+}
+
+// i32 outer1
+void emit_outer1(TCGv_i32 tmp5, TCGv_i32 cond, TCGv_i32 b) {
+TCGv_i32 tmp6 = tcg_temp_new_i32();
+tcg_gen_add_i32(tmp6, b, tcg_constant_i32(5));
+tcg_gen_movcond_i32(TCG_COND_EQ, tmp5, cond, tcg_constant_i32(0), tcg_constant_i32(0), tmp6);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/cpustate.c b/subprojects/helper-to-tcg/tests/ref/21/cpustate.c
new file mode 100644
index 0000000000..e022a14d0c
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/cpustate.c
@@ -0,0 +1,36 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "cpustate.h"
+
+extern TCGv_i32 tcg_regs[32];
+extern TCGv_i32 tcg_a[8];
+extern TCGv_i32 tcg_field;
+// i32 helper_reg
+void emit_reg(TCGv_i32 tmp5, TCGv_ptr env, uint32_t i) {
+tcg_gen_mov_i32(tmp5, tcg_regs[((uint64_t) (uint32_t) i)]);
+}
+
+// i32 helper_data_a
+void emit_data_a(TCGv_i32 tmp6, TCGv_ptr env, uint32_t i) {
+tcg_gen_mov_i32(tmp6, tcg_a[((uint64_t) (uint32_t) i)]);
+}
+
+// i32 helper_single_mapped
+void emit_single_mapped(TCGv_i32 tmp4, TCGv_ptr env) {
+tcg_gen_mov_i32(tmp4, tcg_field);
+}
+
+// i32 helper_unmapped
+void emit_unmapped(TCGv_i32 tmp2, TCGv_ptr env) {
+TCGv_ptr ptr3 = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(ptr3, env, 128ull);
+tcg_gen_ld_i32(tmp2, ptr3, 0);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/forward-context.c b/subprojects/helper-to-tcg/tests/ref/21/forward-context.c
new file mode 100644
index 0000000000..a1c0e5f37a
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/forward-context.c
@@ -0,0 +1,30 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "translate.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "forward-context.h"
+
+#include "translate.h"
+// i32 f0
+void emit_f0(DisasContext *ctx, TCGv_i32 tmp2, TCGv_i32 a, TCGv_i32 off) {
+TCGv_i32 tmp3 = tcg_temp_new_i32();
+tmp3 = fdecl0(ctx, off);
+tcg_gen_add_i32(tmp2, tmp3, a);
+}
+
+// i32 f1
+void emit_f1(DisasContext *ctx, TCGv_i32 tmp2, TCGv_i32 a) {
+TCGv_i32 tmp4 = tcg_temp_new_i32();
+tmp4 = fdecl0(ctx, a);
+tcg_gen_sub_i32(tmp2, tcg_constant_i32(0), a);
+TCGv_i32 tmp3 = tcg_temp_new_i32();
+tmp3 = fdecl0(ctx, tmp2);
+tcg_gen_add_i32(tmp2, tmp3, tmp4);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/ldst.c b/subprojects/helper-to-tcg/tests/ref/21/ldst.c
new file mode 100644
index 0000000000..5710b0b285
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/ldst.c
@@ -0,0 +1,21 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "ldst.h"
+
+// i32 helper_ld8
+void emit_ld8(TCGv_i32 tmp4, TCGv_ptr env, TCGv_i32 addr) {
+tcg_gen_qemu_ld_i32(tmp4, addr, tb_mmu_index(tcg_ctx->gen_tb->flags), MO_8);
+}
+
+// void helper_st8
+void emit_st8(TCGv_ptr env, TCGv_i32 addr, TCGv_i32 data) {
+tcg_gen_qemu_st_i32(data, addr, tb_mmu_index(tcg_ctx->gen_tb->flags), MO_8);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/scalar.c b/subprojects/helper-to-tcg/tests/ref/21/scalar.c
new file mode 100644
index 0000000000..50fe4307c0
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/scalar.c
@@ -0,0 +1,21 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "scalar.h"
+
+// i32 helper_add
+void emit_add(TCGv_i32 tmp2, TCGv_i32 a, TCGv_i32 b) {
+tcg_gen_add_i32(tmp2, b, a);
+}
+
+// i32 helper_cmov
+void emit_cmov(TCGv_i32 tmp5, TCGv_i32 c0, TCGv_i32 c1, TCGv_i32 a, TCGv_i32 b) {
+tcg_gen_movcond_i32(TCG_COND_LTU, tmp5, c0, c1, a, b);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/user-pcrel-jump.c b/subprojects/helper-to-tcg/tests/ref/21/user-pcrel-jump.c
new file mode 100644
index 0000000000..68e6c5d441
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/user-pcrel-jump.c
@@ -0,0 +1,33 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "user-pcrel-jump.h"
+
+// void prcel_jump
+void emit_prcel_jump(TCGv_i32 off) {
+TCGv_i32 ea = tcg_temp_new_i32();
+tcg_gen_shl_i32(ea, off, tcg_constant_i32(2));
+tcg_gen_or_i32(ea, ea, tcg_constant_i32(3));
+target_pcrel_jump(ea);
+}
+
+// void prcel_condjump
+void emit_prcel_condjump(TCGv_i32 cond, TCGv_i32 off) {
+TCGLabel * label8 = gen_new_label();
+TCGLabel * label9 = gen_new_label();
+tcg_gen_brcondi_i32(TCG_COND_EQ, cond, 0, label8);
+gen_set_label(label9);
+TCGv_i32 ea = tcg_temp_new_i32();
+tcg_gen_shl_i32(ea, off, tcg_constant_i32(2));
+tcg_gen_or_i32(ea, ea, tcg_constant_i32(3));
+target_pcrel_jump(ea);
+tcg_gen_br(label8);
+gen_set_label(label8);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f16L.c b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f16L.c
new file mode 100644
index 0000000000..146c940bd4
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f16L.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-f16L.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 2;
+const size_t ci = i % 8;
+const size_t bc = c % 2;
+return 16 * b + 8 * bc + ci;
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 2;
+const size_t ci = i % 4;
+const size_t bc = c % 2;
+return 8 * b + 4 * bc + ci;
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 2;
+const size_t ci = i % 2;
+const size_t bc = c % 2;
+return 4 * b + 2 * bc + ci;
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 2;
+const size_t ci = i % 1;
+const size_t bc = c % 2;
+return 2 * b + 1 * bc + ci;
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x807060504030201, 0x100F0E0D0C0B0A09, 0x1817161514131211, 0x201F1E1D1C1B1A19};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x807060504030201);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f16M.c b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f16M.c
new file mode 100644
index 0000000000..76cff20bee
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f16M.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-f16M.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 2;
+const size_t ci = i % 8;
+const size_t bc = c % 2;
+return 16 * b + 8 * (1 - bc) + (7 - ci);
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 2;
+const size_t ci = i % 4;
+const size_t bc = c % 2;
+return 8 * b + 4 * (1 - bc) + (3 - ci);
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 2;
+const size_t ci = i % 2;
+const size_t bc = c % 2;
+return 4 * b + 2 * (1 - bc) + (1 - ci);
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 2;
+const size_t ci = i % 1;
+const size_t bc = c % 2;
+return 2 * b + 1 * (1 - bc) + (0 - ci);
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x90A0B0C0D0E0F10, 0x102030405060708, 0x191A1B1C1D1E1F20, 0x1112131415161718};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x102030405060708);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f32L.c b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f32L.c
new file mode 100644
index 0000000000..8515b3488e
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f32L.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-f32L.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 4;
+const size_t ci = i % 8;
+const size_t bc = c % 4;
+return 32 * b + 8 * bc + ci;
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 4;
+const size_t ci = i % 4;
+const size_t bc = c % 4;
+return 16 * b + 4 * bc + ci;
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 4;
+const size_t ci = i % 2;
+const size_t bc = c % 4;
+return 8 * b + 2 * bc + ci;
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 4;
+const size_t ci = i % 1;
+const size_t bc = c % 4;
+return 4 * b + 1 * bc + ci;
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x807060504030201, 0x100F0E0D0C0B0A09, 0x1817161514131211, 0x201F1E1D1C1B1A19};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x807060504030201);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f32M.c b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f32M.c
new file mode 100644
index 0000000000..41067c4c62
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f32M.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-f32M.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 4;
+const size_t ci = i % 8;
+const size_t bc = c % 4;
+return 32 * b + 8 * (3 - bc) + (7 - ci);
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 4;
+const size_t ci = i % 4;
+const size_t bc = c % 4;
+return 16 * b + 4 * (3 - bc) + (3 - ci);
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 4;
+const size_t ci = i % 2;
+const size_t bc = c % 4;
+return 8 * b + 2 * (3 - bc) + (1 - ci);
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 4;
+const size_t ci = i % 1;
+const size_t bc = c % 4;
+return 4 * b + 1 * (3 - bc) + (0 - ci);
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x191A1B1C1D1E1F20, 0x1112131415161718, 0x90A0B0C0D0E0F10, 0x102030405060708};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x102030405060708);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f64L.c b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f64L.c
new file mode 100644
index 0000000000..d8e660be8b
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f64L.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-f64L.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 8;
+const size_t ci = i % 8;
+const size_t bc = c % 8;
+return 64 * b + 8 * bc + ci;
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 8;
+const size_t ci = i % 4;
+const size_t bc = c % 8;
+return 32 * b + 4 * bc + ci;
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 8;
+const size_t ci = i % 2;
+const size_t bc = c % 8;
+return 16 * b + 2 * bc + ci;
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 8;
+const size_t ci = i % 1;
+const size_t bc = c % 8;
+return 8 * b + 1 * bc + ci;
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x807060504030201, 0x100F0E0D0C0B0A09, 0x1817161514131211, 0x201F1E1D1C1B1A19};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x807060504030201);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f64M.c b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f64M.c
new file mode 100644
index 0000000000..facfe730c1
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f64M.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-f64M.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 8;
+const size_t ci = i % 8;
+const size_t bc = c % 8;
+return 64 * b + 8 * (7 - bc) + (7 - ci);
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 8;
+const size_t ci = i % 4;
+const size_t bc = c % 8;
+return 32 * b + 4 * (7 - bc) + (3 - ci);
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 8;
+const size_t ci = i % 2;
+const size_t bc = c % 8;
+return 16 * b + 2 * (7 - bc) + (1 - ci);
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 8;
+const size_t ci = i % 1;
+const size_t bc = c % 8;
+return 8 * b + 1 * (7 - bc) + (0 - ci);
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x191A1B1C1D1E1F20, 0x1112131415161718, 0x90A0B0C0D0E0F10, 0x102030405060708};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x102030405060708);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f8L.c b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f8L.c
new file mode 100644
index 0000000000..98f4d0a584
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f8L.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-f8L.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 1;
+const size_t ci = i % 8;
+const size_t bc = c % 1;
+return 8 * b + 8 * bc + ci;
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 1;
+const size_t ci = i % 4;
+const size_t bc = c % 1;
+return 4 * b + 4 * bc + ci;
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 1;
+const size_t ci = i % 2;
+const size_t bc = c % 1;
+return 2 * b + 2 * bc + ci;
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 1;
+const size_t ci = i % 1;
+const size_t bc = c % 1;
+return 1 * b + 1 * bc + ci;
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x807060504030201, 0x100F0E0D0C0B0A09, 0x1817161514131211, 0x201F1E1D1C1B1A19};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x807060504030201);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f8M.c b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f8M.c
new file mode 100644
index 0000000000..a768efc628
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-f8M.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-f8M.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 1;
+const size_t ci = i % 8;
+const size_t bc = c % 1;
+return 8 * b + 8 * (0 - bc) + (7 - ci);
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 1;
+const size_t ci = i % 4;
+const size_t bc = c % 1;
+return 4 * b + 4 * (0 - bc) + (3 - ci);
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 1;
+const size_t ci = i % 2;
+const size_t bc = c % 1;
+return 2 * b + 2 * (0 - bc) + (1 - ci);
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 1;
+const size_t ci = i % 1;
+const size_t bc = c % 1;
+return 1 * b + 1 * (0 - bc) + (0 - ci);
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x102030405060708, 0x90A0B0C0D0E0F10, 0x1112131415161718, 0x191A1B1C1D1E1F20};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x102030405060708);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t16L.c b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t16L.c
new file mode 100644
index 0000000000..ca6944fa92
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t16L.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-t16L.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 2;
+const size_t ci = i % 8;
+const size_t bc = c % 2;
+return 16 * b + 8 * (1 - bc) + (7 - ci);
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 2;
+const size_t ci = i % 4;
+const size_t bc = c % 2;
+return 8 * b + 4 * (1 - bc) + (3 - ci);
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 2;
+const size_t ci = i % 2;
+const size_t bc = c % 2;
+return 4 * b + 2 * (1 - bc) + (1 - ci);
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 2;
+const size_t ci = i % 1;
+const size_t bc = c % 2;
+return 2 * b + 1 * (1 - bc) + (0 - ci);
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x100F0E0D0C0B0A09, 0x807060504030201, 0x201F1E1D1C1B1A19, 0x1817161514131211};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x807060504030201);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t16M.c b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t16M.c
new file mode 100644
index 0000000000..a4e0ca054f
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t16M.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-t16M.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 2;
+const size_t ci = i % 8;
+const size_t bc = c % 2;
+return 16 * b + 8 * bc + ci;
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 2;
+const size_t ci = i % 4;
+const size_t bc = c % 2;
+return 8 * b + 4 * bc + ci;
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 2;
+const size_t ci = i % 2;
+const size_t bc = c % 2;
+return 4 * b + 2 * bc + ci;
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 2;
+const size_t ci = i % 1;
+const size_t bc = c % 2;
+return 2 * b + 1 * bc + ci;
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x102030405060708, 0x90A0B0C0D0E0F10, 0x1112131415161718, 0x191A1B1C1D1E1F20};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x102030405060708);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t32L.c b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t32L.c
new file mode 100644
index 0000000000..b142d9b8ce
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t32L.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-t32L.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 4;
+const size_t ci = i % 8;
+const size_t bc = c % 4;
+return 32 * b + 8 * (3 - bc) + (7 - ci);
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 4;
+const size_t ci = i % 4;
+const size_t bc = c % 4;
+return 16 * b + 4 * (3 - bc) + (3 - ci);
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 4;
+const size_t ci = i % 2;
+const size_t bc = c % 4;
+return 8 * b + 2 * (3 - bc) + (1 - ci);
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 4;
+const size_t ci = i % 1;
+const size_t bc = c % 4;
+return 4 * b + 1 * (3 - bc) + (0 - ci);
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x201F1E1D1C1B1A19, 0x1817161514131211, 0x100F0E0D0C0B0A09, 0x807060504030201};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x807060504030201);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t32M.c b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t32M.c
new file mode 100644
index 0000000000..109ab19c39
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t32M.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-t32M.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 4;
+const size_t ci = i % 8;
+const size_t bc = c % 4;
+return 32 * b + 8 * bc + ci;
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 4;
+const size_t ci = i % 4;
+const size_t bc = c % 4;
+return 16 * b + 4 * bc + ci;
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 4;
+const size_t ci = i % 2;
+const size_t bc = c % 4;
+return 8 * b + 2 * bc + ci;
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 4;
+const size_t ci = i % 1;
+const size_t bc = c % 4;
+return 4 * b + 1 * bc + ci;
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x102030405060708, 0x90A0B0C0D0E0F10, 0x1112131415161718, 0x191A1B1C1D1E1F20};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x102030405060708);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t64L.c b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t64L.c
new file mode 100644
index 0000000000..4f325caa75
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t64L.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-t64L.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 8;
+const size_t ci = i % 8;
+const size_t bc = c % 8;
+return 64 * b + 8 * (7 - bc) + (7 - ci);
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 8;
+const size_t ci = i % 4;
+const size_t bc = c % 8;
+return 32 * b + 4 * (7 - bc) + (3 - ci);
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 8;
+const size_t ci = i % 2;
+const size_t bc = c % 8;
+return 16 * b + 2 * (7 - bc) + (1 - ci);
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 8;
+const size_t ci = i % 1;
+const size_t bc = c % 8;
+return 8 * b + 1 * (7 - bc) + (0 - ci);
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x201F1E1D1C1B1A19, 0x1817161514131211, 0x100F0E0D0C0B0A09, 0x807060504030201};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x807060504030201);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t64M.c b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t64M.c
new file mode 100644
index 0000000000..766a827128
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t64M.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-t64M.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 8;
+const size_t ci = i % 8;
+const size_t bc = c % 8;
+return 64 * b + 8 * bc + ci;
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 8;
+const size_t ci = i % 4;
+const size_t bc = c % 8;
+return 32 * b + 4 * bc + ci;
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 8;
+const size_t ci = i % 2;
+const size_t bc = c % 8;
+return 16 * b + 2 * bc + ci;
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 8;
+const size_t ci = i % 1;
+const size_t bc = c % 8;
+return 8 * b + 1 * bc + ci;
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x102030405060708, 0x90A0B0C0D0E0F10, 0x1112131415161718, 0x191A1B1C1D1E1F20};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x102030405060708);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t8L.c b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t8L.c
new file mode 100644
index 0000000000..18feb85fad
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t8L.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-t8L.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 1;
+const size_t ci = i % 8;
+const size_t bc = c % 1;
+return 8 * b + 8 * (0 - bc) + (7 - ci);
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 1;
+const size_t ci = i % 4;
+const size_t bc = c % 1;
+return 4 * b + 4 * (0 - bc) + (3 - ci);
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 1;
+const size_t ci = i % 2;
+const size_t bc = c % 1;
+return 2 * b + 2 * (0 - bc) + (1 - ci);
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 1;
+const size_t ci = i % 1;
+const size_t bc = c % 1;
+return 1 * b + 1 * (0 - bc) + (0 - ci);
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x807060504030201, 0x100F0E0D0C0B0A09, 0x1817161514131211, 0x201F1E1D1C1B1A19};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x807060504030201);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t8M.c b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t8M.c
new file mode 100644
index 0000000000..97ebe17e91
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector-layout-t8M.c
@@ -0,0 +1,527 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector-layout-t8M.h"
+
+#define HELPER_H "helper-to-tcg-support-helpers.h"
+#include "exec/helper-proto-common.h"
+#include "exec/helper-proto.h.inc"
+#include "exec/helper-gen-common.h"
+#include "exec/helper-gen.h.inc"
+
+inline size_t ind_8(size_t i) {
+const size_t c = i / 8;
+const size_t b = c / 1;
+const size_t ci = i % 8;
+const size_t bc = c % 1;
+return 8 * b + 8 * bc + ci;
+}
+
+inline size_t ind_16(size_t i) {
+const size_t c = i / 4;
+const size_t b = c / 1;
+const size_t ci = i % 4;
+const size_t bc = c % 1;
+return 4 * b + 4 * bc + ci;
+}
+
+inline size_t ind_32(size_t i) {
+const size_t c = i / 2;
+const size_t b = c / 1;
+const size_t ci = i % 2;
+const size_t bc = c % 1;
+return 2 * b + 2 * bc + ci;
+}
+
+inline size_t ind_64(size_t i) {
+const size_t c = i / 1;
+const size_t b = c / 1;
+const size_t ci = i % 1;
+const size_t bc = c % 1;
+return 1 * b + 1 * bc + ci;
+}
+
+void HELPER(vec_trunc_16_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_16_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_16_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_8)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint8_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_8(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_8(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint8_t)); ++i) {
+uint8_t aa = *((uint8_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_8_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int8_t)); ++i) {
+int8_t aa = *((int8_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_8_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_8_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_32_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_32_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_32_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_16)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint16_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_16(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_16(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint16_t)); ++i) {
+uint16_t aa = *((uint16_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_16_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int16_t)); ++i) {
+int16_t aa = *((int16_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_16_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_16_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_trunc_64_32)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint64_t)); ++i) {
+uint64_t aa = *((uint64_t *) a + i);
+*((uint32_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_trunc_64_32(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_trunc_64_32(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_zext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(uint32_t)); ++i) {
+uint32_t aa = *((uint32_t *) a + i);
+*((uint64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_zext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_zext_32_64(d, a, tcg_constant_i32(size));
+}
+
+void HELPER(vec_sext_32_64)(void *d, void *a, uint32_t size)
+{
+for (intptr_t i = 0; i < (size / sizeof(int32_t)); ++i) {
+int32_t aa = *((int32_t *) a + i);
+*((int64_t *) d + i) = aa;
+}
+}
+
+static inline void G_GNUC_UNUSED gen_vec_sext_32_64(intptr_t dofs, intptr_t aofs, uint32_t size)
+{
+TCGv_ptr d = tcg_temp_new_ptr();
+TCGv_ptr a = tcg_temp_new_ptr();
+tcg_gen_addi_ptr(d, tcg_env, dofs);
+tcg_gen_addi_ptr(a, tcg_env, aofs);
+gen_helper_vec_sext_32_64(d, a, tcg_constant_i32(size));
+}
+
+typedef struct VectorMem {
+ uint32_t allocated;
+} VectorMem;
+
+static intptr_t temp_new_gvec(VectorMem *mem, uint32_t size)
+{
+ uint32_t off = ROUND_UP(mem->allocated, size);
+ g_assert(off + size <= STRUCT_SIZEOF_FIELD(CPUArchState, tmp_vmem));
+ mem->allocated = off + size;
+ return offsetof(CPUArchState, tmp_vmem) + off;
+}
+// void helper_vec_constant
+void emit_vec_constant(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+static const uint64_t vec4_data[] = {0x102030405060708, 0x90A0B0C0D0E0F10, 0x1112131415161718, 0x191A1B1C1D1E1F20};
+tcg_gen_gvec_mov_var(MO_64, tcg_env, vec4, tcg_constant_ptr(vec4_data), 0, 32, 32);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_splat
+void emit_vec_splat(intptr_t d, intptr_t a) {
+VectorMem mem = {0};
+intptr_t vec4 = temp_new_gvec(&mem, 32);
+tcg_gen_gvec_dup_imm(MO_64, vec4, 32, 32, 0x102030405060708);
+tcg_gen_gvec_add(MO_8, d, a, vec4, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint8_t
+void emit_vec_trunc_uint64_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 32);
+gen_vec_trunc_64_8(vec5, b, 256);
+tcg_gen_gvec_add(MO_8, d, vec5, vec6, 32, 32);
+}
+
+// void helper_vec_trunc_uint64_t_uint16_t
+void emit_vec_trunc_uint64_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec6, a, 256);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_trunc_64_16(vec5, b, 256);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_trunc_uint32_t_uint8_t
+void emit_vec_trunc_uint32_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_8(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint32_t_uint16_t
+void emit_vec_trunc_uint32_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+tcg_gen_gvec_add(MO_32, vec6, b, a, 128, 128);
+gen_vec_trunc_32_16(d, vec6, 128);
+}
+
+// void helper_vec_trunc_uint16_t_uint8_t
+void emit_vec_trunc_uint16_t_uint8_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+tcg_gen_gvec_add(MO_16, vec6, b, a, 64, 64);
+gen_vec_trunc_16_8(d, vec6, 64);
+}
+
+// void helper_vec_zext_uint8_t_uint64_t
+void emit_vec_zext_uint8_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint16_t_uint64_t
+void emit_vec_zext_uint16_t_uint64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_zext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_zext_uint8_t_uint32_t
+void emit_vec_zext_uint8_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint16_t_uint32_t
+void emit_vec_zext_uint16_t_uint32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_zext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_zext_uint8_t_uint16_t
+void emit_vec_zext_uint8_t_uint16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_zext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
+// void helper_vec_sext_int8_t_int64_t
+void emit_vec_sext_int8_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_8_64(vec5, b, 32);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int16_t_int64_t
+void emit_vec_sext_int16_t_int64_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 256);
+gen_vec_sext_16_64(vec5, b, 64);
+tcg_gen_gvec_add(MO_64, d, vec5, vec6, 256, 256);
+}
+
+// void helper_vec_sext_int8_t_int32_t
+void emit_vec_sext_int8_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_8_32(vec5, b, 32);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int16_t_int32_t
+void emit_vec_sext_int16_t_int32_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec6, a, 64);
+intptr_t vec5 = temp_new_gvec(&mem, 128);
+gen_vec_sext_16_32(vec5, b, 64);
+tcg_gen_gvec_add(MO_32, d, vec5, vec6, 128, 128);
+}
+
+// void helper_vec_sext_int8_t_int16_t
+void emit_vec_sext_int8_t_int16_t(intptr_t d, intptr_t a, intptr_t b) {
+VectorMem mem = {0};
+intptr_t vec6 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec6, a, 32);
+intptr_t vec5 = temp_new_gvec(&mem, 64);
+gen_vec_sext_8_16(vec5, b, 32);
+tcg_gen_gvec_add(MO_16, d, vec5, vec6, 64, 64);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/ref/21/vector.c b/subprojects/helper-to-tcg/tests/ref/21/vector.c
new file mode 100644
index 0000000000..deeec8e8ab
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/ref/21/vector.c
@@ -0,0 +1,31 @@
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "cpu.h"
+#include "translate.h"
+#include "tcg/tcg-op.h"
+#include "tcg/tcg-op-gvec.h"
+#include "tcg/tcg.h"
+#include "tcg/tcg-global-mappings.h"
+#include "exec/translation-block.h"
+#include "vector.h"
+
+// void helper_vec_splat_reg
+void emit_vec_splat_reg(intptr_t d, TCGv_i32 imm) {
+tcg_gen_gvec_dup_i32(MO_8, d, 32ull, 32ull, imm);
+}
+
+// void helper_vec_splat_imm
+void emit_vec_splat_imm(intptr_t d, uint8_t imm) {
+tcg_gen_gvec_dup_imm(MO_8, d, 32ull, 32ull, imm);
+}
+
+// void helper_vec_add
+void emit_vec_add(intptr_t d, intptr_t a, intptr_t b) {
+tcg_gen_gvec_add(MO_8, d, b, a, 32, 32);
+}
+
+// void helper_vec_add32
+void emit_vec_add32(intptr_t d, intptr_t a, intptr_t b) {
+tcg_gen_gvec_add(MO_32, d, b, a, 128, 128);
+}
+
diff --git a/subprojects/helper-to-tcg/tests/scalar.c b/subprojects/helper-to-tcg/tests/scalar.c
new file mode 100644
index 0000000000..09af72371d
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/scalar.c
@@ -0,0 +1,15 @@
+#include <stdint.h>
+
+/* Simple arithmetic */
+uint32_t helper_add(uint32_t a, uint32_t b) {
+ return a + b;
+}
+
+/* Control flow reducable to conditinal move */
+uint32_t helper_cmov(uint32_t c0, uint32_t c1, uint32_t a, uint32_t b) {
+ if (c0 < c1) {
+ return a;
+ } else {
+ return b;
+ }
+}
diff --git a/subprojects/helper-to-tcg/tests/tcg-global-mappings.h b/subprojects/helper-to-tcg/tests/tcg-global-mappings.h
new file mode 100644
index 0000000000..341dcd20b3
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/tcg-global-mappings.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright(c) 2026 rev.ng Labs Srl. All Rights Reserved.
+ *
+ * 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 2 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 this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TCG_GLOBAL_MAP_H
+#define TCG_GLOBAL_MAP_H
+
+/**
+ * cpu_tcg_mapping: Declarative mapping of offsets into a struct to global
+ * TCGvs. Parseable by LLVM-based tools.
+ * @tcg_var_name: String name of the TCGv to use as destination of the mapping.
+ * @tcg_var_base_address: Address of the above TCGv.
+ * @cpu_type_name: String name of the base type being mapped, e.g. "CPUArchState".
+ * @cpu_var_names: Array of printable names of TCGvs, used when calling
+ * tcg_global_mem_new from init_cpu_tcg_mappings. Contains
+ * @number_of_elements strings.
+ * @cpu_var_base_offset: Base offset of field in the source struct.
+ * @cpu_var_size: Size of field in the source struct, if the field is an array,
+ * this holds the size of the element type.
+ * @cpu_var_stride: Stride between array elements in the source struct. This
+ * can be greater than the element size when mapping a field
+ * in an array of structs.
+ * @number_of_elements: Number of elements of array in the source struct.
+ */
+typedef struct cpu_tcg_mapping {
+ const char *tcg_var_name;
+ void *tcg_var_base_address;
+
+ const char *cpu_type_name;
+ const char *const *cpu_var_names;
+ size_t cpu_var_base_offset;
+ size_t cpu_var_size;
+ size_t cpu_var_stride;
+
+ size_t number_of_elements;
+} cpu_tcg_mapping;
+
+#define STRUCT_SIZEOF_FIELD(S, member) sizeof(((S *)0)->member)
+
+#define STRUCT_ARRAY_SIZE(S, array) \
+ (STRUCT_SIZEOF_FIELD(S, array) / STRUCT_SIZEOF_FIELD(S, array[0]))
+
+/*
+ * Following are a few macros that aid in constructing
+ * `cpu_tcg_mapping`s for a few common cases.
+ */
+
+/* Map between single CPU register and to TCG global */
+#define CPU_TCG_MAP(struct_type, tcg_var, cpu_var) \
+ (cpu_tcg_mapping) \
+ { \
+ .tcg_var_name = stringify(tcg_var), \
+ .tcg_var_base_address = &tcg_var, \
+ .cpu_type_name = stringify(struct_type), \
+ .cpu_var_names = (const char *[]){stringify(cpu_var)}, \
+ .cpu_var_base_offset = offsetof(struct_type, cpu_var), \
+ .cpu_var_size = STRUCT_SIZEOF_FIELD(struct_type, cpu_var), \
+ .cpu_var_stride = 0, .number_of_elements = 1, \
+ }
+
+/* Map between array of CPU registers and array of TCG globals. */
+#define CPU_TCG_MAP_ARRAY(struct_type, tcg_var, cpu_var, names) \
+ (cpu_tcg_mapping) \
+ { \
+ .tcg_var_name = stringify(tcg_var), \
+ .tcg_var_base_address = tcg_var, \
+ .cpu_type_name = stringify(struct_type), \
+ .cpu_var_names = names, \
+ .cpu_var_base_offset = offsetof(struct_type, cpu_var), \
+ .cpu_var_size = STRUCT_SIZEOF_FIELD(struct_type, cpu_var[0]), \
+ .cpu_var_stride = STRUCT_SIZEOF_FIELD(struct_type, cpu_var[0]), \
+ .number_of_elements = STRUCT_ARRAY_SIZE(struct_type, cpu_var), \
+ }
+
+/*
+ * Map between single member in an array of structs to an array
+ * of TCG globals, e.g. maps
+ *
+ * cpu_state.array_of_structs[i].member
+ *
+ * to
+ *
+ * tcg_global_member[i]
+ */
+#define CPU_TCG_MAP_ARRAY_OF_STRUCTS(struct_type, tcg_var, cpu_struct, \
+ cpu_var, names) \
+ (cpu_tcg_mapping) \
+ { \
+ .tcg_var_name = stringify(tcg_var), \
+ .tcg_var_base_address = tcg_var, \
+ .cpu_type_name = stringify(struct_type), \
+ .cpu_var_names = names, \
+ .cpu_var_base_offset = offsetof(struct_type, cpu_struct[0].cpu_var), \
+ .cpu_var_size = \
+ STRUCT_SIZEOF_FIELD(struct_type, cpu_struct[0].cpu_var), \
+ .cpu_var_stride = STRUCT_SIZEOF_FIELD(struct_type, cpu_struct[0]), \
+ .number_of_elements = STRUCT_ARRAY_SIZE(struct_type, cpu_struct), \
+ }
+
+extern cpu_tcg_mapping tcg_global_mappings[];
+extern size_t tcg_global_mapping_count;
+
+void init_cpu_tcg_mappings(cpu_tcg_mapping *mappings, size_t size);
+
+#endif /* TCG_GLOBAL_MAP_H */
diff --git a/subprojects/helper-to-tcg/tests/user-pcrel-jump.c b/subprojects/helper-to-tcg/tests/user-pcrel-jump.c
new file mode 100644
index 0000000000..7c0f89c374
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/user-pcrel-jump.c
@@ -0,0 +1,28 @@
+/*
+ * Test translation custom jump instructions
+ *
+ * (experimental)
+ */
+
+#define ANNOTATE(str) __attribute__((annotate("helper-to-tcg")))
+
+ANNOTATE("immediate: 0")
+void target_pcrel_jump(int pc);
+ANNOTATE("immediate: 0")
+void target_pcrel_jump_cond(int pc);
+ANNOTATE("immediate: 0")
+void target_pcrel_jump_fall(int pc);
+
+ANNOTATE("helper-to-tcg")
+void prcel_jump(int off) {
+ int ea = 4*off + 3;
+ target_pcrel_jump(ea);
+}
+
+ANNOTATE("helper-to-tcg")
+void prcel_condjump(int cond, int off) {
+ if (cond) {
+ int ea = 4*off + 3;
+ target_pcrel_jump(ea);
+ }
+}
diff --git a/subprojects/helper-to-tcg/tests/vector-layout.c b/subprojects/helper-to-tcg/tests/vector-layout.c
new file mode 100644
index 0000000000..fa7d1857c7
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/vector-layout.c
@@ -0,0 +1,51 @@
+#include <stdint.h>
+#include <string.h>
+
+__attribute__((annotate("ptr-to-offset: 0, 1"))) void
+helper_vec_constant(void *restrict d, void *restrict a) {
+ const uint8_t arr[] = {
+ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+ 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+ };
+ for (int i = 0; i < 32; ++i) {
+ ((uint8_t *)d)[i] = ((uint8_t *)a)[i] + arr[i];
+ }
+}
+
+__attribute__((annotate("ptr-to-offset: 0, 1"))) void
+helper_vec_splat(void *restrict d, void *restrict a) {
+ const uint8_t arr[] = {
+ 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8,
+ 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8,
+ };
+ for (int i = 0; i < 32; ++i) {
+ ((uint8_t *)d)[i] = ((uint8_t *)a)[i] + arr[i];
+ }
+}
+
+#define GENSZ(NAME, SRC, DST) \
+ __attribute__((annotate("ptr-to-offset: 0, 1, 2"))) void \
+ helper_vec_##NAME##_##SRC##_##DST(void *restrict d, void *restrict a, \
+ void *restrict b) { \
+ for (int i = 0; i < 32; ++i) { \
+ ((DST *)d)[i] = (DST)((SRC *)a)[i] + (DST)((SRC *)b)[i]; \
+ } \
+ }
+
+GENSZ(trunc, uint64_t, uint8_t)
+GENSZ(trunc, uint64_t, uint16_t)
+GENSZ(trunc, uint32_t, uint8_t)
+GENSZ(trunc, uint32_t, uint16_t)
+GENSZ(trunc, uint16_t, uint8_t)
+
+GENSZ(zext, uint8_t, uint64_t)
+GENSZ(zext, uint16_t, uint64_t)
+GENSZ(zext, uint8_t, uint32_t)
+GENSZ(zext, uint16_t, uint32_t)
+GENSZ(zext, uint8_t, uint16_t)
+
+GENSZ(sext, int8_t, int64_t)
+GENSZ(sext, int16_t, int64_t)
+GENSZ(sext, int8_t, int32_t)
+GENSZ(sext, int16_t, int32_t)
+GENSZ(sext, int8_t, int16_t)
diff --git a/subprojects/helper-to-tcg/tests/vector.c b/subprojects/helper-to-tcg/tests/vector.c
new file mode 100644
index 0000000000..b823976dca
--- /dev/null
+++ b/subprojects/helper-to-tcg/tests/vector.c
@@ -0,0 +1,34 @@
+#include <stdint.h>
+
+__attribute__((annotate("ptr-to-offset: 0"))) void
+helper_vec_splat_reg(void *restrict d, uint8_t imm)
+{
+ for (int i = 0; i < 32; ++i) {
+ ((uint8_t *)d)[i] = imm;
+ }
+}
+
+__attribute__((annotate("immediate: 1")))
+__attribute__((annotate("ptr-to-offset: 0"))) void
+helper_vec_splat_imm(void *restrict d, uint8_t imm)
+{
+ for (int i = 0; i < 32; ++i) {
+ ((uint8_t *)d)[i] = imm;
+ }
+}
+
+__attribute__((annotate("ptr-to-offset: 0, 1, 2"))) void
+helper_vec_add(void *restrict d, void *restrict a, void *restrict b)
+{
+ for (int i = 0; i < 32; ++i) {
+ ((uint8_t *)d)[i] = ((uint8_t *)a)[i] + ((uint8_t *)b)[i];
+ }
+}
+
+__attribute__((annotate("ptr-to-offset: 0, 1, 2"))) void
+helper_vec_add32(void *restrict d, void *restrict a, void *restrict b)
+{
+ for (int i = 0; i < 32; ++i) {
+ ((uint32_t *)d)[i] = ((uint32_t *)a)[i] + ((uint32_t *)b)[i];
+ }
+}
--
2.52.0
next prev parent reply other threads:[~2026-07-30 3:11 UTC|newest]
Thread overview: 71+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-07-30 3:09 [PATCH v2 00/50] Introduce helper-to-tcg Anton Johansson via qemu development
2026-07-30 3:09 ` [PATCH v2 01/50] accel/tcg: Add bitreverse and funnel-shift runtime helper functions Anton Johansson via qemu development
2026-07-30 8:04 ` Philippe Mathieu-Daudé
2026-07-30 14:43 ` Richard Henderson
2026-07-30 3:09 ` [PATCH v2 02/50] accel/tcg: Add getpc helper Anton Johansson via qemu development
2026-07-30 14:48 ` Richard Henderson
2026-07-30 3:09 ` [PATCH v2 03/50] tcg: Introduce tcg-global-mappings Anton Johansson via qemu development
2026-07-30 16:11 ` Richard Henderson
2026-07-30 3:09 ` [PATCH v2 04/50] tcg: Increase maximum TB size Anton Johansson via qemu development
2026-07-30 16:13 ` Richard Henderson
2026-07-30 3:09 ` [PATCH v2 05/50] tcg: Expose tcg_gen_ussub_sat() Anton Johansson via qemu development
2026-07-30 7:52 ` Philippe Mathieu-Daudé
2026-07-30 16:17 ` Richard Henderson
2026-07-30 3:09 ` [PATCH v2 06/50] Add helper-to-tcg subproject Anton Johansson via qemu development
2026-07-30 15:56 ` Alessandro Di Federico via qemu development
2026-07-30 3:09 ` [PATCH v2 07/50] helper-to-tcg: Introduce get-llvm-ir.py Anton Johansson via qemu development
2026-08-04 12:08 ` Alessandro Di Federico via qemu development
2026-07-30 3:09 ` [PATCH v2 08/50] helper-to-tcg: Handle LLVM version compatibility Anton Johansson via qemu development
2026-07-30 3:09 ` [PATCH v2 09/50] helper-to-tcg: Introduce custom LLVM pipeline Anton Johansson via qemu development
2026-07-30 3:09 ` [PATCH v2 10/50] helper-to-tcg: Add pipeline --debug and --debug-only Anton Johansson via qemu development
2026-07-30 3:09 ` [PATCH v2 11/50] helper-to-tcg: Add simple error creation helper Anton Johansson via qemu development
2026-07-30 3:09 ` [PATCH v2 12/50] helper-to-tcg: Introduce PrepareForOptPass Anton Johansson via qemu development
2026-07-30 3:09 ` [PATCH v2 13/50] helper-to-tcg: PrepareForOptPass, demangle function names Anton Johansson via qemu development
2026-08-07 16:03 ` Alessandro Di Federico via qemu development
2026-07-30 3:09 ` [PATCH v2 14/50] helper-to-tcg: PrepareForOptPass, map annotations Anton Johansson via qemu development
2026-08-07 10:26 ` Alessandro Di Federico via qemu development
2026-07-30 3:09 ` [PATCH v2 15/50] helper-to-tcg: PrepareForOptPass, cull unused functions Anton Johansson via qemu development
2026-07-30 3:09 ` [PATCH v2 16/50] helper-to-tcg: PrepareForOptPass, undef llvm.returnaddress Anton Johansson via qemu development
2026-07-30 3:09 ` [PATCH v2 17/50] helper-to-tcg: PrepareForOptPass, fixup inline attributes Anton Johansson via qemu development
2026-07-30 3:09 ` [PATCH v2 18/50] helper-to-tcg: PrepareForOptPass, collect debuginfo Anton Johansson via qemu development
2026-07-30 3:09 ` [PATCH v2 19/50] helper-to-tcg: Pipeline, run optimization pass Anton Johansson via qemu development
2026-07-30 3:09 ` [PATCH v2 20/50] helper-to-tcg: Introduce pseudo instructions Anton Johansson via qemu development
2026-07-30 3:09 ` [PATCH v2 21/50] helper-to-tcg: Add guest vector layout description Anton Johansson via qemu development
2026-07-30 3:09 ` [PATCH v2 22/50] helper-to-tcg: Introduce PrepareForTcgPass Anton Johansson via qemu development
2026-07-30 3:09 ` [PATCH v2 23/50] helper-to-tcg: PrepareForTcgPass, remove functions with cycles Anton Johansson via qemu development
2026-07-30 3:09 ` [PATCH v2 24/50] helper-to-tcg: PrepareForTcgPass, demote PHI nodes Anton Johansson via qemu development
2026-07-30 3:09 ` [PATCH v2 25/50] helper-to-tcg: PrepareForTcgPass, map TCG globals Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 26/50] helper-to-tcg: PrepareForTcgPass, transform GEPs Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 27/50] helper-to-tcg: PrepareForTcgPass, canonicalize IR Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 28/50] helper-to-tcg: PrepareForTcgPass, identity map trivial expressions Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 29/50] helper-to-tcg: Introduce TcgV structure Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 30/50] helper-to-tcg: Introduce TcgGenPass Anton Johansson via qemu development
2026-08-07 10:27 ` Alessandro Di Federico via qemu development
2026-07-30 3:10 ` [PATCH v2 31/50] helper-to-tcg: TcgGenPass, linearize basic blocks Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 32/50] helper-to-tcg: TcgGenPass, introduce Value <-> TcgV map Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 33/50] helper-to-tcg: TcgGenPass, add structs for string emission Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 34/50] helper-to-tcg: TcgGenPass, map arguments to TCG Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 35/50] helper-to-tcg: TcgGenPass, propagate constant expresssions Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 36/50] helper-to-tcg: TcgGenPass, allocate TCG registers Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 37/50] helper-to-tcg: TcgGenPass, emit TCG strings Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 38/50] helper-to-tcg: Add README Anton Johansson via qemu development
2026-07-30 3:10 ` Anton Johansson via qemu development [this message]
2026-07-30 3:10 ` [PATCH v2 40/50] test: helper-to-tcg docker tests Anton Johansson via qemu development
2026-07-31 11:46 ` Alessandro Di Federico via qemu development
2026-07-31 11:48 ` Alessandro Di Federico via qemu development
2026-07-31 16:47 ` Pierrick Bouvier
2026-07-30 3:10 ` [PATCH v2 41/50] target/hexagon: Add get_tb_mmu_index() Anton Johansson via qemu development
2026-07-30 7:49 ` Philippe Mathieu-Daudé
2026-07-30 3:10 ` [PATCH v2 42/50] target/hexagon: Increase VECTOR_TEMPS_MAX Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 43/50] target/hexagon: Provide env to tcg global mapping Anton Johansson via qemu development
2026-07-30 16:28 ` Richard Henderson
2026-07-30 3:10 ` [PATCH v2 44/50] target/hexagon: Keep gen_slotval/check_noshuf for helper-to-tcg Anton Johansson via qemu development
2026-07-31 11:46 ` Alessandro Di Federico via qemu development
2026-07-30 3:10 ` [PATCH v2 45/50] target/hexagon: Emit annotations for helpers Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 46/50] target/hexagon: Split probe_and_commit helper Anton Johansson via qemu development
2026-07-30 7:50 ` Philippe Mathieu-Daudé
2026-07-30 3:10 ` [PATCH v2 47/50] target/hexagon: Use helper-to-tcg helper calls Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 48/50] target/hexagon: Manually call generated HVX instructions Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 49/50] target/hexagon: Use idef-parser as a fallback Anton Johansson via qemu development
2026-07-30 3:10 ` [PATCH v2 50/50] target/hexagon: Use helper-to-tcg Anton Johansson via qemu development
2026-08-04 12:08 ` Alessandro Di Federico via qemu development
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20260730031025.12926-40-anjo@rev.ng \
--to=qemu-devel@nongnu.org \
--cc=ale@rev.ng \
--cc=anjo@rev.ng \
--cc=brian.cain@oss.qualcomm.com \
--cc=philmd@mailo.com \
--cc=pierrick.bouvier@oss.qualcomm.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.