From ca52c9d5f0a6cc36c110d29f484e40a8044ea0d2 Mon Sep 17 00:00:00 2001 From: eopXD Date: Sat, 4 Nov 2023 07:42:06 -0700 Subject: [PATCH] [Auto-gen] Update tests under ../auto-generated. (make git-commit-autogen-test) --- auto-generated/api-testing/vle16.c | 27 +++++----- auto-generated/api-testing/vle16ff.c | 24 ++++----- auto-generated/api-testing/vloxei16.c | 24 ++++----- auto-generated/api-testing/vloxei32.c | 20 +++---- auto-generated/api-testing/vloxei64.c | 16 +++--- auto-generated/api-testing/vloxei8.c | 24 ++++----- auto-generated/api-testing/vloxseg2ei16.c | 26 +++++----- auto-generated/api-testing/vloxseg2ei32.c | 26 +++++----- auto-generated/api-testing/vloxseg2ei64.c | 20 +++---- auto-generated/api-testing/vloxseg2ei8.c | 22 ++++---- auto-generated/api-testing/vloxseg3ei16.c | 20 +++---- auto-generated/api-testing/vloxseg3ei32.c | 20 +++---- auto-generated/api-testing/vloxseg3ei64.c | 20 +++---- auto-generated/api-testing/vloxseg3ei8.c | 18 +++---- auto-generated/api-testing/vloxseg4ei16.c | 20 +++---- auto-generated/api-testing/vloxseg4ei32.c | 20 +++---- auto-generated/api-testing/vloxseg4ei64.c | 20 +++---- auto-generated/api-testing/vloxseg4ei8.c | 18 +++---- auto-generated/api-testing/vloxseg5ei16.c | 14 ++--- auto-generated/api-testing/vloxseg5ei32.c | 14 ++--- auto-generated/api-testing/vloxseg5ei64.c | 14 ++--- auto-generated/api-testing/vloxseg5ei8.c | 14 +++-- auto-generated/api-testing/vloxseg6ei16.c | 14 ++--- auto-generated/api-testing/vloxseg6ei32.c | 14 ++--- auto-generated/api-testing/vloxseg6ei64.c | 14 ++--- auto-generated/api-testing/vloxseg6ei8.c | 14 +++-- auto-generated/api-testing/vloxseg7ei16.c | 14 ++--- auto-generated/api-testing/vloxseg7ei32.c | 14 ++--- auto-generated/api-testing/vloxseg7ei64.c | 14 ++--- auto-generated/api-testing/vloxseg7ei8.c | 14 +++-- auto-generated/api-testing/vloxseg8ei16.c | 14 ++--- auto-generated/api-testing/vloxseg8ei32.c | 14 ++--- auto-generated/api-testing/vloxseg8ei64.c | 14 ++--- auto-generated/api-testing/vloxseg8ei8.c | 14 +++-- auto-generated/api-testing/vlse16.c | 24 ++++----- auto-generated/api-testing/vlseg2e16.c | 20 +++---- auto-generated/api-testing/vlseg2e16ff.c | 26 +++++----- auto-generated/api-testing/vlseg3e16.c | 16 +++--- auto-generated/api-testing/vlseg3e16ff.c | 22 ++++---- auto-generated/api-testing/vlseg4e16.c | 16 +++--- auto-generated/api-testing/vlseg4e16ff.c | 22 ++++---- auto-generated/api-testing/vlseg5e16.c | 12 ++--- auto-generated/api-testing/vlseg5e16ff.c | 18 +++---- auto-generated/api-testing/vlseg6e16.c | 12 ++--- auto-generated/api-testing/vlseg6e16ff.c | 18 +++---- auto-generated/api-testing/vlseg7e16.c | 12 ++--- auto-generated/api-testing/vlseg7e16ff.c | 18 +++---- auto-generated/api-testing/vlseg8e16.c | 12 ++--- auto-generated/api-testing/vlseg8e16ff.c | 18 +++---- auto-generated/api-testing/vlsseg2e16.c | 20 +++---- auto-generated/api-testing/vlsseg3e16.c | 16 +++--- auto-generated/api-testing/vlsseg4e16.c | 16 +++--- auto-generated/api-testing/vlsseg5e16.c | 12 ++--- auto-generated/api-testing/vlsseg6e16.c | 12 ++--- auto-generated/api-testing/vlsseg7e16.c | 12 ++--- auto-generated/api-testing/vlsseg8e16.c | 12 ++--- auto-generated/api-testing/vluxei16.c | 24 ++++----- auto-generated/api-testing/vluxei32.c | 20 +++---- auto-generated/api-testing/vluxei64.c | 16 +++--- auto-generated/api-testing/vluxei8.c | 24 ++++----- auto-generated/api-testing/vluxseg2ei16.c | 26 +++++----- auto-generated/api-testing/vluxseg2ei32.c | 26 +++++----- auto-generated/api-testing/vluxseg2ei64.c | 20 +++---- auto-generated/api-testing/vluxseg2ei8.c | 22 ++++---- auto-generated/api-testing/vluxseg3ei16.c | 20 +++---- auto-generated/api-testing/vluxseg3ei32.c | 20 +++---- auto-generated/api-testing/vluxseg3ei64.c | 20 +++---- auto-generated/api-testing/vluxseg3ei8.c | 18 +++---- auto-generated/api-testing/vluxseg4ei16.c | 20 +++---- auto-generated/api-testing/vluxseg4ei32.c | 20 +++---- auto-generated/api-testing/vluxseg4ei64.c | 20 +++---- auto-generated/api-testing/vluxseg4ei8.c | 18 +++---- auto-generated/api-testing/vluxseg5ei16.c | 14 ++--- auto-generated/api-testing/vluxseg5ei32.c | 14 ++--- auto-generated/api-testing/vluxseg5ei64.c | 14 ++--- auto-generated/api-testing/vluxseg5ei8.c | 14 +++-- auto-generated/api-testing/vluxseg6ei16.c | 14 ++--- auto-generated/api-testing/vluxseg6ei32.c | 14 ++--- auto-generated/api-testing/vluxseg6ei64.c | 14 ++--- auto-generated/api-testing/vluxseg6ei8.c | 14 +++-- auto-generated/api-testing/vluxseg7ei16.c | 14 ++--- auto-generated/api-testing/vluxseg7ei32.c | 14 ++--- auto-generated/api-testing/vluxseg7ei64.c | 14 ++--- auto-generated/api-testing/vluxseg7ei8.c | 14 +++-- auto-generated/api-testing/vluxseg8ei16.c | 14 ++--- auto-generated/api-testing/vluxseg8ei32.c | 14 ++--- auto-generated/api-testing/vluxseg8ei64.c | 14 ++--- auto-generated/api-testing/vluxseg8ei8.c | 14 +++-- auto-generated/api-testing/vse16.c | 24 ++++----- auto-generated/api-testing/vsoxei16.c | 24 ++++----- auto-generated/api-testing/vsoxei32.c | 20 +++---- auto-generated/api-testing/vsoxei64.c | 16 +++--- auto-generated/api-testing/vsoxei8.c | 24 ++++----- auto-generated/api-testing/vsoxseg2ei16.c | 23 ++++---- auto-generated/api-testing/vsoxseg2ei32.c | 23 ++++---- auto-generated/api-testing/vsoxseg2ei64.c | 19 ++++--- auto-generated/api-testing/vsoxseg2ei8.c | 26 +++++----- auto-generated/api-testing/vsoxseg3ei16.c | 19 ++++--- auto-generated/api-testing/vsoxseg3ei32.c | 19 ++++--- auto-generated/api-testing/vsoxseg3ei64.c | 19 ++++--- auto-generated/api-testing/vsoxseg3ei8.c | 22 ++++---- auto-generated/api-testing/vsoxseg4ei16.c | 19 ++++--- auto-generated/api-testing/vsoxseg4ei32.c | 19 ++++--- auto-generated/api-testing/vsoxseg4ei64.c | 19 ++++--- auto-generated/api-testing/vsoxseg4ei8.c | 22 ++++---- auto-generated/api-testing/vsoxseg5ei16.c | 15 +++--- auto-generated/api-testing/vsoxseg5ei32.c | 15 +++--- auto-generated/api-testing/vsoxseg5ei64.c | 15 +++--- auto-generated/api-testing/vsoxseg5ei8.c | 18 +++---- auto-generated/api-testing/vsoxseg6ei16.c | 15 +++--- auto-generated/api-testing/vsoxseg6ei32.c | 15 +++--- auto-generated/api-testing/vsoxseg6ei64.c | 15 +++--- auto-generated/api-testing/vsoxseg6ei8.c | 18 +++---- auto-generated/api-testing/vsoxseg7ei16.c | 15 +++--- auto-generated/api-testing/vsoxseg7ei32.c | 15 +++--- auto-generated/api-testing/vsoxseg7ei64.c | 15 +++--- auto-generated/api-testing/vsoxseg7ei8.c | 18 +++---- auto-generated/api-testing/vsoxseg8ei16.c | 15 +++--- auto-generated/api-testing/vsoxseg8ei32.c | 15 +++--- auto-generated/api-testing/vsoxseg8ei64.c | 15 +++--- auto-generated/api-testing/vsoxseg8ei8.c | 18 +++---- auto-generated/api-testing/vsse16.c | 24 ++++----- auto-generated/api-testing/vsseg2e16.c | 22 ++++---- auto-generated/api-testing/vsseg3e16.c | 18 +++---- auto-generated/api-testing/vsseg4e16.c | 18 +++---- auto-generated/api-testing/vsseg5e16.c | 14 ++--- auto-generated/api-testing/vsseg6e16.c | 14 ++--- auto-generated/api-testing/vsseg7e16.c | 14 ++--- auto-generated/api-testing/vsseg8e16.c | 14 ++--- auto-generated/api-testing/vssseg2e16.c | 26 +++++----- auto-generated/api-testing/vssseg3e16.c | 20 +++---- auto-generated/api-testing/vssseg4e16.c | 20 +++---- auto-generated/api-testing/vssseg5e16.c | 14 ++--- auto-generated/api-testing/vssseg6e16.c | 14 ++--- auto-generated/api-testing/vssseg7e16.c | 14 ++--- auto-generated/api-testing/vssseg8e16.c | 14 ++--- auto-generated/api-testing/vsuxei16.c | 24 ++++----- auto-generated/api-testing/vsuxei32.c | 20 +++---- auto-generated/api-testing/vsuxei64.c | 16 +++--- auto-generated/api-testing/vsuxei8.c | 24 ++++----- auto-generated/api-testing/vsuxseg2ei16.c | 23 ++++---- auto-generated/api-testing/vsuxseg2ei32.c | 23 ++++---- auto-generated/api-testing/vsuxseg2ei64.c | 19 ++++--- auto-generated/api-testing/vsuxseg2ei8.c | 26 +++++----- auto-generated/api-testing/vsuxseg3ei16.c | 19 ++++--- auto-generated/api-testing/vsuxseg3ei32.c | 19 ++++--- auto-generated/api-testing/vsuxseg3ei64.c | 19 ++++--- auto-generated/api-testing/vsuxseg3ei8.c | 22 ++++---- auto-generated/api-testing/vsuxseg4ei16.c | 19 ++++--- auto-generated/api-testing/vsuxseg4ei32.c | 19 ++++--- auto-generated/api-testing/vsuxseg4ei64.c | 19 ++++--- auto-generated/api-testing/vsuxseg4ei8.c | 22 ++++---- auto-generated/api-testing/vsuxseg5ei16.c | 15 +++--- auto-generated/api-testing/vsuxseg5ei32.c | 15 +++--- auto-generated/api-testing/vsuxseg5ei64.c | 15 +++--- auto-generated/api-testing/vsuxseg5ei8.c | 18 +++---- auto-generated/api-testing/vsuxseg6ei16.c | 15 +++--- auto-generated/api-testing/vsuxseg6ei32.c | 15 +++--- auto-generated/api-testing/vsuxseg6ei64.c | 15 +++--- auto-generated/api-testing/vsuxseg6ei8.c | 18 +++---- auto-generated/api-testing/vsuxseg7ei16.c | 15 +++--- auto-generated/api-testing/vsuxseg7ei32.c | 15 +++--- auto-generated/api-testing/vsuxseg7ei64.c | 15 +++--- auto-generated/api-testing/vsuxseg7ei8.c | 18 +++---- auto-generated/api-testing/vsuxseg8ei16.c | 15 +++--- auto-generated/api-testing/vsuxseg8ei32.c | 15 +++--- auto-generated/api-testing/vsuxseg8ei64.c | 15 +++--- auto-generated/api-testing/vsuxseg8ei8.c | 18 +++---- auto-generated/gnu-api-tests/vle16.c | 24 ++++----- auto-generated/gnu-api-tests/vle16ff.c | 24 ++++----- auto-generated/gnu-api-tests/vloxei16.c | 24 ++++----- auto-generated/gnu-api-tests/vloxei32.c | 20 +++---- auto-generated/gnu-api-tests/vloxei64.c | 16 +++--- auto-generated/gnu-api-tests/vloxei8.c | 24 ++++----- auto-generated/gnu-api-tests/vloxseg2ei16.c | 20 +++---- auto-generated/gnu-api-tests/vloxseg2ei32.c | 20 +++---- auto-generated/gnu-api-tests/vloxseg2ei64.c | 16 +++--- auto-generated/gnu-api-tests/vloxseg2ei8.c | 20 +++---- auto-generated/gnu-api-tests/vloxseg3ei16.c | 16 +++--- auto-generated/gnu-api-tests/vloxseg3ei32.c | 16 +++--- auto-generated/gnu-api-tests/vloxseg3ei64.c | 16 +++--- auto-generated/gnu-api-tests/vloxseg3ei8.c | 16 +++--- auto-generated/gnu-api-tests/vloxseg4ei16.c | 16 +++--- auto-generated/gnu-api-tests/vloxseg4ei32.c | 16 +++--- auto-generated/gnu-api-tests/vloxseg4ei64.c | 16 +++--- auto-generated/gnu-api-tests/vloxseg4ei8.c | 16 +++--- auto-generated/gnu-api-tests/vloxseg5ei16.c | 12 ++--- auto-generated/gnu-api-tests/vloxseg5ei32.c | 12 ++--- auto-generated/gnu-api-tests/vloxseg5ei64.c | 12 ++--- auto-generated/gnu-api-tests/vloxseg5ei8.c | 12 ++--- auto-generated/gnu-api-tests/vloxseg6ei16.c | 12 ++--- auto-generated/gnu-api-tests/vloxseg6ei32.c | 12 ++--- auto-generated/gnu-api-tests/vloxseg6ei64.c | 12 ++--- auto-generated/gnu-api-tests/vloxseg6ei8.c | 12 ++--- auto-generated/gnu-api-tests/vloxseg7ei16.c | 12 ++--- auto-generated/gnu-api-tests/vloxseg7ei32.c | 12 ++--- auto-generated/gnu-api-tests/vloxseg7ei64.c | 12 ++--- auto-generated/gnu-api-tests/vloxseg7ei8.c | 12 ++--- auto-generated/gnu-api-tests/vloxseg8ei16.c | 12 ++--- auto-generated/gnu-api-tests/vloxseg8ei32.c | 12 ++--- auto-generated/gnu-api-tests/vloxseg8ei64.c | 12 ++--- auto-generated/gnu-api-tests/vloxseg8ei8.c | 12 ++--- auto-generated/gnu-api-tests/vlse16.c | 24 ++++----- auto-generated/gnu-api-tests/vlseg2e16.c | 20 +++---- auto-generated/gnu-api-tests/vlseg2e16ff.c | 20 +++---- auto-generated/gnu-api-tests/vlseg3e16.c | 16 +++--- auto-generated/gnu-api-tests/vlseg3e16ff.c | 16 +++--- auto-generated/gnu-api-tests/vlseg4e16.c | 16 +++--- auto-generated/gnu-api-tests/vlseg4e16ff.c | 16 +++--- auto-generated/gnu-api-tests/vlseg5e16.c | 12 ++--- auto-generated/gnu-api-tests/vlseg5e16ff.c | 12 ++--- auto-generated/gnu-api-tests/vlseg6e16.c | 12 ++--- auto-generated/gnu-api-tests/vlseg6e16ff.c | 12 ++--- auto-generated/gnu-api-tests/vlseg7e16.c | 12 ++--- auto-generated/gnu-api-tests/vlseg7e16ff.c | 12 ++--- auto-generated/gnu-api-tests/vlseg8e16.c | 12 ++--- auto-generated/gnu-api-tests/vlseg8e16ff.c | 12 ++--- auto-generated/gnu-api-tests/vlsseg2e16.c | 20 +++---- auto-generated/gnu-api-tests/vlsseg3e16.c | 16 +++--- auto-generated/gnu-api-tests/vlsseg4e16.c | 16 +++--- auto-generated/gnu-api-tests/vlsseg5e16.c | 12 ++--- auto-generated/gnu-api-tests/vlsseg6e16.c | 12 ++--- auto-generated/gnu-api-tests/vlsseg7e16.c | 12 ++--- auto-generated/gnu-api-tests/vlsseg8e16.c | 12 ++--- auto-generated/gnu-api-tests/vluxei16.c | 24 ++++----- auto-generated/gnu-api-tests/vluxei32.c | 20 +++---- auto-generated/gnu-api-tests/vluxei64.c | 16 +++--- auto-generated/gnu-api-tests/vluxei8.c | 24 ++++----- auto-generated/gnu-api-tests/vluxseg2ei16.c | 20 +++---- auto-generated/gnu-api-tests/vluxseg2ei32.c | 20 +++---- auto-generated/gnu-api-tests/vluxseg2ei64.c | 16 +++--- auto-generated/gnu-api-tests/vluxseg2ei8.c | 20 +++---- auto-generated/gnu-api-tests/vluxseg3ei16.c | 16 +++--- auto-generated/gnu-api-tests/vluxseg3ei32.c | 16 +++--- auto-generated/gnu-api-tests/vluxseg3ei64.c | 16 +++--- auto-generated/gnu-api-tests/vluxseg3ei8.c | 16 +++--- auto-generated/gnu-api-tests/vluxseg4ei16.c | 16 +++--- auto-generated/gnu-api-tests/vluxseg4ei32.c | 16 +++--- auto-generated/gnu-api-tests/vluxseg4ei64.c | 16 +++--- auto-generated/gnu-api-tests/vluxseg4ei8.c | 16 +++--- auto-generated/gnu-api-tests/vluxseg5ei16.c | 12 ++--- auto-generated/gnu-api-tests/vluxseg5ei32.c | 12 ++--- auto-generated/gnu-api-tests/vluxseg5ei64.c | 12 ++--- auto-generated/gnu-api-tests/vluxseg5ei8.c | 12 ++--- auto-generated/gnu-api-tests/vluxseg6ei16.c | 12 ++--- auto-generated/gnu-api-tests/vluxseg6ei32.c | 12 ++--- auto-generated/gnu-api-tests/vluxseg6ei64.c | 12 ++--- auto-generated/gnu-api-tests/vluxseg6ei8.c | 12 ++--- auto-generated/gnu-api-tests/vluxseg7ei16.c | 12 ++--- auto-generated/gnu-api-tests/vluxseg7ei32.c | 12 ++--- auto-generated/gnu-api-tests/vluxseg7ei64.c | 12 ++--- auto-generated/gnu-api-tests/vluxseg7ei8.c | 12 ++--- auto-generated/gnu-api-tests/vluxseg8ei16.c | 12 ++--- auto-generated/gnu-api-tests/vluxseg8ei32.c | 12 ++--- auto-generated/gnu-api-tests/vluxseg8ei64.c | 12 ++--- auto-generated/gnu-api-tests/vluxseg8ei8.c | 12 ++--- auto-generated/gnu-api-tests/vse16.c | 24 ++++----- auto-generated/gnu-api-tests/vsoxei16.c | 24 ++++----- auto-generated/gnu-api-tests/vsoxei32.c | 20 +++---- auto-generated/gnu-api-tests/vsoxei64.c | 16 +++--- auto-generated/gnu-api-tests/vsoxei8.c | 24 ++++----- auto-generated/gnu-api-tests/vsoxseg2ei16.c | 20 +++---- auto-generated/gnu-api-tests/vsoxseg2ei32.c | 20 +++---- auto-generated/gnu-api-tests/vsoxseg2ei64.c | 16 +++--- auto-generated/gnu-api-tests/vsoxseg2ei8.c | 20 +++---- auto-generated/gnu-api-tests/vsoxseg3ei16.c | 16 +++--- auto-generated/gnu-api-tests/vsoxseg3ei32.c | 16 +++--- auto-generated/gnu-api-tests/vsoxseg3ei64.c | 16 +++--- auto-generated/gnu-api-tests/vsoxseg3ei8.c | 16 +++--- auto-generated/gnu-api-tests/vsoxseg4ei16.c | 16 +++--- auto-generated/gnu-api-tests/vsoxseg4ei32.c | 16 +++--- auto-generated/gnu-api-tests/vsoxseg4ei64.c | 16 +++--- auto-generated/gnu-api-tests/vsoxseg4ei8.c | 16 +++--- auto-generated/gnu-api-tests/vsoxseg5ei16.c | 12 ++--- auto-generated/gnu-api-tests/vsoxseg5ei32.c | 12 ++--- auto-generated/gnu-api-tests/vsoxseg5ei64.c | 12 ++--- auto-generated/gnu-api-tests/vsoxseg5ei8.c | 12 ++--- auto-generated/gnu-api-tests/vsoxseg6ei16.c | 12 ++--- auto-generated/gnu-api-tests/vsoxseg6ei32.c | 12 ++--- auto-generated/gnu-api-tests/vsoxseg6ei64.c | 12 ++--- auto-generated/gnu-api-tests/vsoxseg6ei8.c | 12 ++--- auto-generated/gnu-api-tests/vsoxseg7ei16.c | 12 ++--- auto-generated/gnu-api-tests/vsoxseg7ei32.c | 12 ++--- auto-generated/gnu-api-tests/vsoxseg7ei64.c | 12 ++--- auto-generated/gnu-api-tests/vsoxseg7ei8.c | 12 ++--- auto-generated/gnu-api-tests/vsoxseg8ei16.c | 12 ++--- auto-generated/gnu-api-tests/vsoxseg8ei32.c | 12 ++--- auto-generated/gnu-api-tests/vsoxseg8ei64.c | 12 ++--- auto-generated/gnu-api-tests/vsoxseg8ei8.c | 12 ++--- auto-generated/gnu-api-tests/vsse16.c | 24 ++++----- auto-generated/gnu-api-tests/vsseg2e16.c | 20 +++---- auto-generated/gnu-api-tests/vsseg3e16.c | 16 +++--- auto-generated/gnu-api-tests/vsseg4e16.c | 16 +++--- auto-generated/gnu-api-tests/vsseg5e16.c | 12 ++--- auto-generated/gnu-api-tests/vsseg6e16.c | 12 ++--- auto-generated/gnu-api-tests/vsseg7e16.c | 12 ++--- auto-generated/gnu-api-tests/vsseg8e16.c | 12 ++--- auto-generated/gnu-api-tests/vssseg2e16.c | 20 +++---- auto-generated/gnu-api-tests/vssseg3e16.c | 16 +++--- auto-generated/gnu-api-tests/vssseg4e16.c | 16 +++--- auto-generated/gnu-api-tests/vssseg5e16.c | 12 ++--- auto-generated/gnu-api-tests/vssseg6e16.c | 12 ++--- auto-generated/gnu-api-tests/vssseg7e16.c | 12 ++--- auto-generated/gnu-api-tests/vssseg8e16.c | 12 ++--- auto-generated/gnu-api-tests/vsuxei16.c | 24 ++++----- auto-generated/gnu-api-tests/vsuxei32.c | 20 +++---- auto-generated/gnu-api-tests/vsuxei64.c | 16 +++--- auto-generated/gnu-api-tests/vsuxei8.c | 24 ++++----- auto-generated/gnu-api-tests/vsuxseg2ei16.c | 20 +++---- auto-generated/gnu-api-tests/vsuxseg2ei32.c | 20 +++---- auto-generated/gnu-api-tests/vsuxseg2ei64.c | 16 +++--- auto-generated/gnu-api-tests/vsuxseg2ei8.c | 20 +++---- auto-generated/gnu-api-tests/vsuxseg3ei16.c | 16 +++--- auto-generated/gnu-api-tests/vsuxseg3ei32.c | 16 +++--- auto-generated/gnu-api-tests/vsuxseg3ei64.c | 16 +++--- auto-generated/gnu-api-tests/vsuxseg3ei8.c | 16 +++--- auto-generated/gnu-api-tests/vsuxseg4ei16.c | 16 +++--- auto-generated/gnu-api-tests/vsuxseg4ei32.c | 16 +++--- auto-generated/gnu-api-tests/vsuxseg4ei64.c | 16 +++--- auto-generated/gnu-api-tests/vsuxseg4ei8.c | 16 +++--- auto-generated/gnu-api-tests/vsuxseg5ei16.c | 12 ++--- auto-generated/gnu-api-tests/vsuxseg5ei32.c | 12 ++--- auto-generated/gnu-api-tests/vsuxseg5ei64.c | 12 ++--- auto-generated/gnu-api-tests/vsuxseg5ei8.c | 12 ++--- auto-generated/gnu-api-tests/vsuxseg6ei16.c | 12 ++--- auto-generated/gnu-api-tests/vsuxseg6ei32.c | 12 ++--- auto-generated/gnu-api-tests/vsuxseg6ei64.c | 12 ++--- auto-generated/gnu-api-tests/vsuxseg6ei8.c | 12 ++--- auto-generated/gnu-api-tests/vsuxseg7ei16.c | 12 ++--- auto-generated/gnu-api-tests/vsuxseg7ei32.c | 12 ++--- auto-generated/gnu-api-tests/vsuxseg7ei64.c | 12 ++--- auto-generated/gnu-api-tests/vsuxseg7ei8.c | 12 ++--- auto-generated/gnu-api-tests/vsuxseg8ei16.c | 12 ++--- auto-generated/gnu-api-tests/vsuxseg8ei32.c | 12 ++--- auto-generated/gnu-api-tests/vsuxseg8ei64.c | 12 ++--- auto-generated/gnu-api-tests/vsuxseg8ei8.c | 12 ++--- auto-generated/gnu-overloaded-tests/vle16.c | 12 ++--- auto-generated/gnu-overloaded-tests/vle16ff.c | 12 ++--- .../gnu-overloaded-tests/vloxei16.c | 24 ++++----- .../gnu-overloaded-tests/vloxei32.c | 20 +++---- .../gnu-overloaded-tests/vloxei64.c | 16 +++--- auto-generated/gnu-overloaded-tests/vloxei8.c | 24 ++++----- .../gnu-overloaded-tests/vloxseg2ei16.c | 20 +++---- .../gnu-overloaded-tests/vloxseg2ei32.c | 20 +++---- .../gnu-overloaded-tests/vloxseg2ei64.c | 16 +++--- .../gnu-overloaded-tests/vloxseg2ei8.c | 20 +++---- .../gnu-overloaded-tests/vloxseg3ei16.c | 16 +++--- .../gnu-overloaded-tests/vloxseg3ei32.c | 16 +++--- .../gnu-overloaded-tests/vloxseg3ei64.c | 16 +++--- .../gnu-overloaded-tests/vloxseg3ei8.c | 16 +++--- .../gnu-overloaded-tests/vloxseg4ei16.c | 16 +++--- .../gnu-overloaded-tests/vloxseg4ei32.c | 16 +++--- .../gnu-overloaded-tests/vloxseg4ei64.c | 16 +++--- .../gnu-overloaded-tests/vloxseg4ei8.c | 16 +++--- .../gnu-overloaded-tests/vloxseg5ei16.c | 12 ++--- .../gnu-overloaded-tests/vloxseg5ei32.c | 12 ++--- .../gnu-overloaded-tests/vloxseg5ei64.c | 12 ++--- .../gnu-overloaded-tests/vloxseg5ei8.c | 12 ++--- .../gnu-overloaded-tests/vloxseg6ei16.c | 12 ++--- .../gnu-overloaded-tests/vloxseg6ei32.c | 12 ++--- .../gnu-overloaded-tests/vloxseg6ei64.c | 12 ++--- .../gnu-overloaded-tests/vloxseg6ei8.c | 12 ++--- .../gnu-overloaded-tests/vloxseg7ei16.c | 12 ++--- .../gnu-overloaded-tests/vloxseg7ei32.c | 12 ++--- .../gnu-overloaded-tests/vloxseg7ei64.c | 12 ++--- .../gnu-overloaded-tests/vloxseg7ei8.c | 12 ++--- .../gnu-overloaded-tests/vloxseg8ei16.c | 12 ++--- .../gnu-overloaded-tests/vloxseg8ei32.c | 12 ++--- .../gnu-overloaded-tests/vloxseg8ei64.c | 12 ++--- .../gnu-overloaded-tests/vloxseg8ei8.c | 12 ++--- auto-generated/gnu-overloaded-tests/vlse16.c | 12 ++--- .../gnu-overloaded-tests/vlseg2e16.c | 10 ++-- .../gnu-overloaded-tests/vlseg2e16ff.c | 10 ++-- .../gnu-overloaded-tests/vlseg3e16.c | 8 +-- .../gnu-overloaded-tests/vlseg3e16ff.c | 8 +-- .../gnu-overloaded-tests/vlseg4e16.c | 8 +-- .../gnu-overloaded-tests/vlseg4e16ff.c | 8 +-- .../gnu-overloaded-tests/vlseg5e16.c | 6 +-- .../gnu-overloaded-tests/vlseg5e16ff.c | 6 +-- .../gnu-overloaded-tests/vlseg6e16.c | 6 +-- .../gnu-overloaded-tests/vlseg6e16ff.c | 6 +-- .../gnu-overloaded-tests/vlseg7e16.c | 6 +-- .../gnu-overloaded-tests/vlseg7e16ff.c | 6 +-- .../gnu-overloaded-tests/vlseg8e16.c | 6 +-- .../gnu-overloaded-tests/vlseg8e16ff.c | 6 +-- .../gnu-overloaded-tests/vlsseg2e16.c | 10 ++-- .../gnu-overloaded-tests/vlsseg3e16.c | 8 +-- .../gnu-overloaded-tests/vlsseg4e16.c | 8 +-- .../gnu-overloaded-tests/vlsseg5e16.c | 6 +-- .../gnu-overloaded-tests/vlsseg6e16.c | 6 +-- .../gnu-overloaded-tests/vlsseg7e16.c | 6 +-- .../gnu-overloaded-tests/vlsseg8e16.c | 6 +-- .../gnu-overloaded-tests/vluxei16.c | 24 ++++----- .../gnu-overloaded-tests/vluxei32.c | 20 +++---- .../gnu-overloaded-tests/vluxei64.c | 16 +++--- auto-generated/gnu-overloaded-tests/vluxei8.c | 24 ++++----- .../gnu-overloaded-tests/vluxseg2ei16.c | 20 +++---- .../gnu-overloaded-tests/vluxseg2ei32.c | 20 +++---- .../gnu-overloaded-tests/vluxseg2ei64.c | 16 +++--- .../gnu-overloaded-tests/vluxseg2ei8.c | 20 +++---- .../gnu-overloaded-tests/vluxseg3ei16.c | 16 +++--- .../gnu-overloaded-tests/vluxseg3ei32.c | 16 +++--- .../gnu-overloaded-tests/vluxseg3ei64.c | 16 +++--- .../gnu-overloaded-tests/vluxseg3ei8.c | 16 +++--- .../gnu-overloaded-tests/vluxseg4ei16.c | 16 +++--- .../gnu-overloaded-tests/vluxseg4ei32.c | 16 +++--- .../gnu-overloaded-tests/vluxseg4ei64.c | 16 +++--- .../gnu-overloaded-tests/vluxseg4ei8.c | 16 +++--- .../gnu-overloaded-tests/vluxseg5ei16.c | 12 ++--- .../gnu-overloaded-tests/vluxseg5ei32.c | 12 ++--- .../gnu-overloaded-tests/vluxseg5ei64.c | 12 ++--- .../gnu-overloaded-tests/vluxseg5ei8.c | 12 ++--- .../gnu-overloaded-tests/vluxseg6ei16.c | 12 ++--- .../gnu-overloaded-tests/vluxseg6ei32.c | 12 ++--- .../gnu-overloaded-tests/vluxseg6ei64.c | 12 ++--- .../gnu-overloaded-tests/vluxseg6ei8.c | 12 ++--- .../gnu-overloaded-tests/vluxseg7ei16.c | 12 ++--- .../gnu-overloaded-tests/vluxseg7ei32.c | 12 ++--- .../gnu-overloaded-tests/vluxseg7ei64.c | 12 ++--- .../gnu-overloaded-tests/vluxseg7ei8.c | 12 ++--- .../gnu-overloaded-tests/vluxseg8ei16.c | 12 ++--- .../gnu-overloaded-tests/vluxseg8ei32.c | 12 ++--- .../gnu-overloaded-tests/vluxseg8ei64.c | 12 ++--- .../gnu-overloaded-tests/vluxseg8ei8.c | 12 ++--- auto-generated/gnu-overloaded-tests/vse16.c | 24 ++++----- .../gnu-overloaded-tests/vsoxei16.c | 24 ++++----- .../gnu-overloaded-tests/vsoxei32.c | 20 +++---- .../gnu-overloaded-tests/vsoxei64.c | 16 +++--- auto-generated/gnu-overloaded-tests/vsoxei8.c | 24 ++++----- .../gnu-overloaded-tests/vsoxseg2ei16.c | 20 +++---- .../gnu-overloaded-tests/vsoxseg2ei32.c | 20 +++---- .../gnu-overloaded-tests/vsoxseg2ei64.c | 16 +++--- .../gnu-overloaded-tests/vsoxseg2ei8.c | 20 +++---- .../gnu-overloaded-tests/vsoxseg3ei16.c | 16 +++--- .../gnu-overloaded-tests/vsoxseg3ei32.c | 16 +++--- .../gnu-overloaded-tests/vsoxseg3ei64.c | 16 +++--- .../gnu-overloaded-tests/vsoxseg3ei8.c | 16 +++--- .../gnu-overloaded-tests/vsoxseg4ei16.c | 16 +++--- .../gnu-overloaded-tests/vsoxseg4ei32.c | 16 +++--- .../gnu-overloaded-tests/vsoxseg4ei64.c | 16 +++--- .../gnu-overloaded-tests/vsoxseg4ei8.c | 16 +++--- .../gnu-overloaded-tests/vsoxseg5ei16.c | 12 ++--- .../gnu-overloaded-tests/vsoxseg5ei32.c | 12 ++--- .../gnu-overloaded-tests/vsoxseg5ei64.c | 12 ++--- .../gnu-overloaded-tests/vsoxseg5ei8.c | 12 ++--- .../gnu-overloaded-tests/vsoxseg6ei16.c | 12 ++--- .../gnu-overloaded-tests/vsoxseg6ei32.c | 12 ++--- .../gnu-overloaded-tests/vsoxseg6ei64.c | 12 ++--- .../gnu-overloaded-tests/vsoxseg6ei8.c | 12 ++--- .../gnu-overloaded-tests/vsoxseg7ei16.c | 12 ++--- .../gnu-overloaded-tests/vsoxseg7ei32.c | 12 ++--- .../gnu-overloaded-tests/vsoxseg7ei64.c | 12 ++--- .../gnu-overloaded-tests/vsoxseg7ei8.c | 12 ++--- .../gnu-overloaded-tests/vsoxseg8ei16.c | 12 ++--- .../gnu-overloaded-tests/vsoxseg8ei32.c | 12 ++--- .../gnu-overloaded-tests/vsoxseg8ei64.c | 12 ++--- .../gnu-overloaded-tests/vsoxseg8ei8.c | 12 ++--- auto-generated/gnu-overloaded-tests/vsse16.c | 24 ++++----- .../gnu-overloaded-tests/vsseg2e16.c | 20 +++---- .../gnu-overloaded-tests/vsseg3e16.c | 16 +++--- .../gnu-overloaded-tests/vsseg4e16.c | 16 +++--- .../gnu-overloaded-tests/vsseg5e16.c | 12 ++--- .../gnu-overloaded-tests/vsseg6e16.c | 12 ++--- .../gnu-overloaded-tests/vsseg7e16.c | 12 ++--- .../gnu-overloaded-tests/vsseg8e16.c | 12 ++--- .../gnu-overloaded-tests/vssseg2e16.c | 20 +++---- .../gnu-overloaded-tests/vssseg3e16.c | 16 +++--- .../gnu-overloaded-tests/vssseg4e16.c | 16 +++--- .../gnu-overloaded-tests/vssseg5e16.c | 12 ++--- .../gnu-overloaded-tests/vssseg6e16.c | 12 ++--- .../gnu-overloaded-tests/vssseg7e16.c | 12 ++--- .../gnu-overloaded-tests/vssseg8e16.c | 12 ++--- .../gnu-overloaded-tests/vsuxei16.c | 24 ++++----- .../gnu-overloaded-tests/vsuxei32.c | 20 +++---- .../gnu-overloaded-tests/vsuxei64.c | 16 +++--- auto-generated/gnu-overloaded-tests/vsuxei8.c | 24 ++++----- .../gnu-overloaded-tests/vsuxseg2ei16.c | 20 +++---- .../gnu-overloaded-tests/vsuxseg2ei32.c | 20 +++---- .../gnu-overloaded-tests/vsuxseg2ei64.c | 16 +++--- .../gnu-overloaded-tests/vsuxseg2ei8.c | 20 +++---- .../gnu-overloaded-tests/vsuxseg3ei16.c | 16 +++--- .../gnu-overloaded-tests/vsuxseg3ei32.c | 16 +++--- .../gnu-overloaded-tests/vsuxseg3ei64.c | 16 +++--- .../gnu-overloaded-tests/vsuxseg3ei8.c | 16 +++--- .../gnu-overloaded-tests/vsuxseg4ei16.c | 16 +++--- .../gnu-overloaded-tests/vsuxseg4ei32.c | 16 +++--- .../gnu-overloaded-tests/vsuxseg4ei64.c | 16 +++--- .../gnu-overloaded-tests/vsuxseg4ei8.c | 16 +++--- .../gnu-overloaded-tests/vsuxseg5ei16.c | 12 ++--- .../gnu-overloaded-tests/vsuxseg5ei32.c | 12 ++--- .../gnu-overloaded-tests/vsuxseg5ei64.c | 12 ++--- .../gnu-overloaded-tests/vsuxseg5ei8.c | 12 ++--- .../gnu-overloaded-tests/vsuxseg6ei16.c | 12 ++--- .../gnu-overloaded-tests/vsuxseg6ei32.c | 12 ++--- .../gnu-overloaded-tests/vsuxseg6ei64.c | 12 ++--- .../gnu-overloaded-tests/vsuxseg6ei8.c | 12 ++--- .../gnu-overloaded-tests/vsuxseg7ei16.c | 12 ++--- .../gnu-overloaded-tests/vsuxseg7ei32.c | 12 ++--- .../gnu-overloaded-tests/vsuxseg7ei64.c | 12 ++--- .../gnu-overloaded-tests/vsuxseg7ei8.c | 12 ++--- .../gnu-overloaded-tests/vsuxseg8ei16.c | 12 ++--- .../gnu-overloaded-tests/vsuxseg8ei32.c | 12 ++--- .../gnu-overloaded-tests/vsuxseg8ei64.c | 12 ++--- .../gnu-overloaded-tests/vsuxseg8ei8.c | 12 ++--- auto-generated/overloaded-api-testing/vle16.c | 15 +++--- .../overloaded-api-testing/vle16ff.c | 12 ++--- .../overloaded-api-testing/vloxei16.c | 24 ++++----- .../overloaded-api-testing/vloxei32.c | 20 +++---- .../overloaded-api-testing/vloxei64.c | 16 +++--- .../overloaded-api-testing/vloxei8.c | 24 ++++----- .../overloaded-api-testing/vloxseg2ei16.c | 26 +++++----- .../overloaded-api-testing/vloxseg2ei32.c | 26 +++++----- .../overloaded-api-testing/vloxseg2ei64.c | 20 +++---- .../overloaded-api-testing/vloxseg2ei8.c | 22 ++++---- .../overloaded-api-testing/vloxseg3ei16.c | 20 +++---- .../overloaded-api-testing/vloxseg3ei32.c | 20 +++---- .../overloaded-api-testing/vloxseg3ei64.c | 20 +++---- .../overloaded-api-testing/vloxseg3ei8.c | 18 +++---- .../overloaded-api-testing/vloxseg4ei16.c | 20 +++---- .../overloaded-api-testing/vloxseg4ei32.c | 20 +++---- .../overloaded-api-testing/vloxseg4ei64.c | 20 +++---- .../overloaded-api-testing/vloxseg4ei8.c | 18 +++---- .../overloaded-api-testing/vloxseg5ei16.c | 14 ++--- .../overloaded-api-testing/vloxseg5ei32.c | 14 ++--- .../overloaded-api-testing/vloxseg5ei64.c | 14 ++--- .../overloaded-api-testing/vloxseg5ei8.c | 14 +++-- .../overloaded-api-testing/vloxseg6ei16.c | 14 ++--- .../overloaded-api-testing/vloxseg6ei32.c | 14 ++--- .../overloaded-api-testing/vloxseg6ei64.c | 14 ++--- .../overloaded-api-testing/vloxseg6ei8.c | 14 +++-- .../overloaded-api-testing/vloxseg7ei16.c | 14 ++--- .../overloaded-api-testing/vloxseg7ei32.c | 14 ++--- .../overloaded-api-testing/vloxseg7ei64.c | 14 ++--- .../overloaded-api-testing/vloxseg7ei8.c | 14 +++-- .../overloaded-api-testing/vloxseg8ei16.c | 14 ++--- .../overloaded-api-testing/vloxseg8ei32.c | 14 ++--- .../overloaded-api-testing/vloxseg8ei64.c | 14 ++--- .../overloaded-api-testing/vloxseg8ei8.c | 14 +++-- .../overloaded-api-testing/vlse16.c | 12 ++--- .../overloaded-api-testing/vlseg2e16.c | 10 ++-- .../overloaded-api-testing/vlseg2e16ff.c | 12 ++--- .../overloaded-api-testing/vlseg3e16.c | 8 +-- .../overloaded-api-testing/vlseg3e16ff.c | 10 ++-- .../overloaded-api-testing/vlseg4e16.c | 8 +-- .../overloaded-api-testing/vlseg4e16ff.c | 10 ++-- .../overloaded-api-testing/vlseg5e16.c | 6 +-- .../overloaded-api-testing/vlseg5e16ff.c | 8 ++- .../overloaded-api-testing/vlseg6e16.c | 6 +-- .../overloaded-api-testing/vlseg6e16ff.c | 8 ++- .../overloaded-api-testing/vlseg7e16.c | 6 +-- .../overloaded-api-testing/vlseg7e16ff.c | 8 ++- .../overloaded-api-testing/vlseg8e16.c | 6 +-- .../overloaded-api-testing/vlseg8e16ff.c | 8 ++- .../overloaded-api-testing/vlsseg2e16.c | 10 ++-- .../overloaded-api-testing/vlsseg3e16.c | 8 +-- .../overloaded-api-testing/vlsseg4e16.c | 8 +-- .../overloaded-api-testing/vlsseg5e16.c | 6 +-- .../overloaded-api-testing/vlsseg6e16.c | 6 +-- .../overloaded-api-testing/vlsseg7e16.c | 6 +-- .../overloaded-api-testing/vlsseg8e16.c | 6 +-- .../overloaded-api-testing/vluxei16.c | 24 ++++----- .../overloaded-api-testing/vluxei32.c | 20 +++---- .../overloaded-api-testing/vluxei64.c | 16 +++--- .../overloaded-api-testing/vluxei8.c | 24 ++++----- .../overloaded-api-testing/vluxseg2ei16.c | 26 +++++----- .../overloaded-api-testing/vluxseg2ei32.c | 26 +++++----- .../overloaded-api-testing/vluxseg2ei64.c | 20 +++---- .../overloaded-api-testing/vluxseg2ei8.c | 22 ++++---- .../overloaded-api-testing/vluxseg3ei16.c | 20 +++---- .../overloaded-api-testing/vluxseg3ei32.c | 20 +++---- .../overloaded-api-testing/vluxseg3ei64.c | 20 +++---- .../overloaded-api-testing/vluxseg3ei8.c | 18 +++---- .../overloaded-api-testing/vluxseg4ei16.c | 20 +++---- .../overloaded-api-testing/vluxseg4ei32.c | 20 +++---- .../overloaded-api-testing/vluxseg4ei64.c | 20 +++---- .../overloaded-api-testing/vluxseg4ei8.c | 18 +++---- .../overloaded-api-testing/vluxseg5ei16.c | 14 ++--- .../overloaded-api-testing/vluxseg5ei32.c | 14 ++--- .../overloaded-api-testing/vluxseg5ei64.c | 14 ++--- .../overloaded-api-testing/vluxseg5ei8.c | 14 +++-- .../overloaded-api-testing/vluxseg6ei16.c | 14 ++--- .../overloaded-api-testing/vluxseg6ei32.c | 14 ++--- .../overloaded-api-testing/vluxseg6ei64.c | 14 ++--- .../overloaded-api-testing/vluxseg6ei8.c | 14 +++-- .../overloaded-api-testing/vluxseg7ei16.c | 14 ++--- .../overloaded-api-testing/vluxseg7ei32.c | 14 ++--- .../overloaded-api-testing/vluxseg7ei64.c | 14 ++--- .../overloaded-api-testing/vluxseg7ei8.c | 14 +++-- .../overloaded-api-testing/vluxseg8ei16.c | 14 ++--- .../overloaded-api-testing/vluxseg8ei32.c | 14 ++--- .../overloaded-api-testing/vluxseg8ei64.c | 14 ++--- .../overloaded-api-testing/vluxseg8ei8.c | 14 +++-- auto-generated/overloaded-api-testing/vse16.c | 24 ++++----- .../overloaded-api-testing/vsoxei16.c | 24 ++++----- .../overloaded-api-testing/vsoxei32.c | 20 +++---- .../overloaded-api-testing/vsoxei64.c | 16 +++--- .../overloaded-api-testing/vsoxei8.c | 24 ++++----- .../overloaded-api-testing/vsoxseg2ei16.c | 23 ++++---- .../overloaded-api-testing/vsoxseg2ei32.c | 23 ++++---- .../overloaded-api-testing/vsoxseg2ei64.c | 19 ++++--- .../overloaded-api-testing/vsoxseg2ei8.c | 26 +++++----- .../overloaded-api-testing/vsoxseg3ei16.c | 19 ++++--- .../overloaded-api-testing/vsoxseg3ei32.c | 19 ++++--- .../overloaded-api-testing/vsoxseg3ei64.c | 19 ++++--- .../overloaded-api-testing/vsoxseg3ei8.c | 22 ++++---- .../overloaded-api-testing/vsoxseg4ei16.c | 19 ++++--- .../overloaded-api-testing/vsoxseg4ei32.c | 19 ++++--- .../overloaded-api-testing/vsoxseg4ei64.c | 19 ++++--- .../overloaded-api-testing/vsoxseg4ei8.c | 22 ++++---- .../overloaded-api-testing/vsoxseg5ei16.c | 15 +++--- .../overloaded-api-testing/vsoxseg5ei32.c | 15 +++--- .../overloaded-api-testing/vsoxseg5ei64.c | 15 +++--- .../overloaded-api-testing/vsoxseg5ei8.c | 18 +++---- .../overloaded-api-testing/vsoxseg6ei16.c | 15 +++--- .../overloaded-api-testing/vsoxseg6ei32.c | 15 +++--- .../overloaded-api-testing/vsoxseg6ei64.c | 15 +++--- .../overloaded-api-testing/vsoxseg6ei8.c | 18 +++---- .../overloaded-api-testing/vsoxseg7ei16.c | 15 +++--- .../overloaded-api-testing/vsoxseg7ei32.c | 15 +++--- .../overloaded-api-testing/vsoxseg7ei64.c | 15 +++--- .../overloaded-api-testing/vsoxseg7ei8.c | 18 +++---- .../overloaded-api-testing/vsoxseg8ei16.c | 15 +++--- .../overloaded-api-testing/vsoxseg8ei32.c | 15 +++--- .../overloaded-api-testing/vsoxseg8ei64.c | 15 +++--- .../overloaded-api-testing/vsoxseg8ei8.c | 18 +++---- .../overloaded-api-testing/vsse16.c | 24 ++++----- .../overloaded-api-testing/vsseg2e16.c | 22 ++++---- .../overloaded-api-testing/vsseg3e16.c | 18 +++---- .../overloaded-api-testing/vsseg4e16.c | 18 +++---- .../overloaded-api-testing/vsseg5e16.c | 14 ++--- .../overloaded-api-testing/vsseg6e16.c | 14 ++--- .../overloaded-api-testing/vsseg7e16.c | 14 ++--- .../overloaded-api-testing/vsseg8e16.c | 14 ++--- .../overloaded-api-testing/vssseg2e16.c | 26 +++++----- .../overloaded-api-testing/vssseg3e16.c | 20 +++---- .../overloaded-api-testing/vssseg4e16.c | 20 +++---- .../overloaded-api-testing/vssseg5e16.c | 14 ++--- .../overloaded-api-testing/vssseg6e16.c | 14 ++--- .../overloaded-api-testing/vssseg7e16.c | 14 ++--- .../overloaded-api-testing/vssseg8e16.c | 14 ++--- .../overloaded-api-testing/vsuxei16.c | 24 ++++----- .../overloaded-api-testing/vsuxei32.c | 20 +++---- .../overloaded-api-testing/vsuxei64.c | 16 +++--- .../overloaded-api-testing/vsuxei8.c | 24 ++++----- .../overloaded-api-testing/vsuxseg2ei16.c | 23 ++++---- .../overloaded-api-testing/vsuxseg2ei32.c | 23 ++++---- .../overloaded-api-testing/vsuxseg2ei64.c | 19 ++++--- .../overloaded-api-testing/vsuxseg2ei8.c | 26 +++++----- .../overloaded-api-testing/vsuxseg3ei16.c | 19 ++++--- .../overloaded-api-testing/vsuxseg3ei32.c | 19 ++++--- .../overloaded-api-testing/vsuxseg3ei64.c | 19 ++++--- .../overloaded-api-testing/vsuxseg3ei8.c | 22 ++++---- .../overloaded-api-testing/vsuxseg4ei16.c | 19 ++++--- .../overloaded-api-testing/vsuxseg4ei32.c | 19 ++++--- .../overloaded-api-testing/vsuxseg4ei64.c | 19 ++++--- .../overloaded-api-testing/vsuxseg4ei8.c | 22 ++++---- .../overloaded-api-testing/vsuxseg5ei16.c | 15 +++--- .../overloaded-api-testing/vsuxseg5ei32.c | 15 +++--- .../overloaded-api-testing/vsuxseg5ei64.c | 15 +++--- .../overloaded-api-testing/vsuxseg5ei8.c | 18 +++---- .../overloaded-api-testing/vsuxseg6ei16.c | 15 +++--- .../overloaded-api-testing/vsuxseg6ei32.c | 15 +++--- .../overloaded-api-testing/vsuxseg6ei64.c | 15 +++--- .../overloaded-api-testing/vsuxseg6ei8.c | 18 +++---- .../overloaded-api-testing/vsuxseg7ei16.c | 15 +++--- .../overloaded-api-testing/vsuxseg7ei32.c | 15 +++--- .../overloaded-api-testing/vsuxseg7ei64.c | 15 +++--- .../overloaded-api-testing/vsuxseg7ei8.c | 18 +++---- .../overloaded-api-testing/vsuxseg8ei16.c | 15 +++--- .../overloaded-api-testing/vsuxseg8ei32.c | 15 +++--- .../overloaded-api-testing/vsuxseg8ei64.c | 15 +++--- .../overloaded-api-testing/vsuxseg8ei8.c | 18 +++---- .../policy_funcs/api-testing/vle16.c | 48 ++++++++--------- .../policy_funcs/api-testing/vle16ff.c | 48 ++++++++--------- .../policy_funcs/api-testing/vloxei16.c | 52 +++++++++---------- .../policy_funcs/api-testing/vloxei32.c | 42 +++++++-------- .../policy_funcs/api-testing/vloxei64.c | 32 ++++++------ .../policy_funcs/api-testing/vloxei8.c | 48 ++++++++--------- .../policy_funcs/api-testing/vloxseg2ei16.c | 40 +++++++------- .../policy_funcs/api-testing/vloxseg2ei32.c | 40 +++++++------- .../policy_funcs/api-testing/vloxseg2ei64.c | 32 ++++++------ .../policy_funcs/api-testing/vloxseg2ei8.c | 40 +++++++------- .../policy_funcs/api-testing/vloxseg3ei16.c | 32 ++++++------ .../policy_funcs/api-testing/vloxseg3ei32.c | 32 ++++++------ .../policy_funcs/api-testing/vloxseg3ei64.c | 32 ++++++------ .../policy_funcs/api-testing/vloxseg3ei8.c | 32 ++++++------ .../policy_funcs/api-testing/vloxseg4ei16.c | 32 ++++++------ .../policy_funcs/api-testing/vloxseg4ei32.c | 32 ++++++------ .../policy_funcs/api-testing/vloxseg4ei64.c | 32 ++++++------ .../policy_funcs/api-testing/vloxseg4ei8.c | 32 ++++++------ .../policy_funcs/api-testing/vloxseg5ei16.c | 24 ++++----- .../policy_funcs/api-testing/vloxseg5ei32.c | 24 ++++----- .../policy_funcs/api-testing/vloxseg5ei64.c | 24 ++++----- .../policy_funcs/api-testing/vloxseg5ei8.c | 24 ++++----- .../policy_funcs/api-testing/vloxseg6ei16.c | 24 ++++----- .../policy_funcs/api-testing/vloxseg6ei32.c | 24 ++++----- .../policy_funcs/api-testing/vloxseg6ei64.c | 24 ++++----- .../policy_funcs/api-testing/vloxseg6ei8.c | 24 ++++----- .../policy_funcs/api-testing/vloxseg7ei16.c | 24 ++++----- .../policy_funcs/api-testing/vloxseg7ei32.c | 24 ++++----- .../policy_funcs/api-testing/vloxseg7ei64.c | 24 ++++----- .../policy_funcs/api-testing/vloxseg7ei8.c | 24 ++++----- .../policy_funcs/api-testing/vloxseg8ei16.c | 24 ++++----- .../policy_funcs/api-testing/vloxseg8ei32.c | 24 ++++----- .../policy_funcs/api-testing/vloxseg8ei64.c | 24 ++++----- .../policy_funcs/api-testing/vloxseg8ei8.c | 24 ++++----- .../policy_funcs/api-testing/vlse16.c | 48 ++++++++--------- .../policy_funcs/api-testing/vlseg2e16.c | 42 +++++++-------- .../policy_funcs/api-testing/vlseg2e16ff.c | 40 +++++++------- .../policy_funcs/api-testing/vlseg3e16.c | 34 ++++++------ .../policy_funcs/api-testing/vlseg3e16ff.c | 32 ++++++------ .../policy_funcs/api-testing/vlseg4e16.c | 34 ++++++------ .../policy_funcs/api-testing/vlseg4e16ff.c | 32 ++++++------ .../policy_funcs/api-testing/vlseg5e16.c | 26 +++++----- .../policy_funcs/api-testing/vlseg5e16ff.c | 24 ++++----- .../policy_funcs/api-testing/vlseg6e16.c | 26 +++++----- .../policy_funcs/api-testing/vlseg6e16ff.c | 24 ++++----- .../policy_funcs/api-testing/vlseg7e16.c | 26 +++++----- .../policy_funcs/api-testing/vlseg7e16ff.c | 24 ++++----- .../policy_funcs/api-testing/vlseg8e16.c | 26 +++++----- .../policy_funcs/api-testing/vlseg8e16ff.c | 24 ++++----- .../policy_funcs/api-testing/vlsseg2e16.c | 46 ++++++++-------- .../policy_funcs/api-testing/vlsseg3e16.c | 36 ++++++------- .../policy_funcs/api-testing/vlsseg4e16.c | 36 ++++++------- .../policy_funcs/api-testing/vlsseg5e16.c | 26 +++++----- .../policy_funcs/api-testing/vlsseg6e16.c | 26 +++++----- .../policy_funcs/api-testing/vlsseg7e16.c | 26 +++++----- .../policy_funcs/api-testing/vlsseg8e16.c | 26 +++++----- .../policy_funcs/api-testing/vluxei16.c | 52 +++++++++---------- .../policy_funcs/api-testing/vluxei32.c | 42 +++++++-------- .../policy_funcs/api-testing/vluxei64.c | 32 ++++++------ .../policy_funcs/api-testing/vluxei8.c | 48 ++++++++--------- .../policy_funcs/api-testing/vluxseg2ei16.c | 40 +++++++------- .../policy_funcs/api-testing/vluxseg2ei32.c | 40 +++++++------- .../policy_funcs/api-testing/vluxseg2ei64.c | 32 ++++++------ .../policy_funcs/api-testing/vluxseg2ei8.c | 40 +++++++------- .../policy_funcs/api-testing/vluxseg3ei16.c | 32 ++++++------ .../policy_funcs/api-testing/vluxseg3ei32.c | 32 ++++++------ .../policy_funcs/api-testing/vluxseg3ei64.c | 32 ++++++------ .../policy_funcs/api-testing/vluxseg3ei8.c | 32 ++++++------ .../policy_funcs/api-testing/vluxseg4ei16.c | 32 ++++++------ .../policy_funcs/api-testing/vluxseg4ei32.c | 32 ++++++------ .../policy_funcs/api-testing/vluxseg4ei64.c | 32 ++++++------ .../policy_funcs/api-testing/vluxseg4ei8.c | 32 ++++++------ .../policy_funcs/api-testing/vluxseg5ei16.c | 24 ++++----- .../policy_funcs/api-testing/vluxseg5ei32.c | 24 ++++----- .../policy_funcs/api-testing/vluxseg5ei64.c | 24 ++++----- .../policy_funcs/api-testing/vluxseg5ei8.c | 24 ++++----- .../policy_funcs/api-testing/vluxseg6ei16.c | 24 ++++----- .../policy_funcs/api-testing/vluxseg6ei32.c | 24 ++++----- .../policy_funcs/api-testing/vluxseg6ei64.c | 24 ++++----- .../policy_funcs/api-testing/vluxseg6ei8.c | 24 ++++----- .../policy_funcs/api-testing/vluxseg7ei16.c | 24 ++++----- .../policy_funcs/api-testing/vluxseg7ei32.c | 24 ++++----- .../policy_funcs/api-testing/vluxseg7ei64.c | 24 ++++----- .../policy_funcs/api-testing/vluxseg7ei8.c | 24 ++++----- .../policy_funcs/api-testing/vluxseg8ei16.c | 24 ++++----- .../policy_funcs/api-testing/vluxseg8ei32.c | 24 ++++----- .../policy_funcs/api-testing/vluxseg8ei64.c | 24 ++++----- .../policy_funcs/api-testing/vluxseg8ei8.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vle16.c | 48 ++++++++--------- .../policy_funcs/gnu-api-tests/vle16ff.c | 48 ++++++++--------- .../policy_funcs/gnu-api-tests/vloxei16.c | 48 ++++++++--------- .../policy_funcs/gnu-api-tests/vloxei32.c | 40 +++++++------- .../policy_funcs/gnu-api-tests/vloxei64.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vloxei8.c | 48 ++++++++--------- .../policy_funcs/gnu-api-tests/vloxseg2ei16.c | 40 +++++++------- .../policy_funcs/gnu-api-tests/vloxseg2ei32.c | 40 +++++++------- .../policy_funcs/gnu-api-tests/vloxseg2ei64.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vloxseg2ei8.c | 40 +++++++------- .../policy_funcs/gnu-api-tests/vloxseg3ei16.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vloxseg3ei32.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vloxseg3ei64.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vloxseg3ei8.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vloxseg4ei16.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vloxseg4ei32.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vloxseg4ei64.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vloxseg4ei8.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vloxseg5ei16.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vloxseg5ei32.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vloxseg5ei64.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vloxseg5ei8.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vloxseg6ei16.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vloxseg6ei32.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vloxseg6ei64.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vloxseg6ei8.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vloxseg7ei16.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vloxseg7ei32.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vloxseg7ei64.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vloxseg7ei8.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vloxseg8ei16.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vloxseg8ei32.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vloxseg8ei64.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vloxseg8ei8.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vlse16.c | 48 ++++++++--------- .../policy_funcs/gnu-api-tests/vlseg2e16.c | 40 +++++++------- .../policy_funcs/gnu-api-tests/vlseg2e16ff.c | 40 +++++++------- .../policy_funcs/gnu-api-tests/vlseg3e16.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vlseg3e16ff.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vlseg4e16.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vlseg4e16ff.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vlseg5e16.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vlseg5e16ff.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vlseg6e16.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vlseg6e16ff.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vlseg7e16.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vlseg7e16ff.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vlseg8e16.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vlseg8e16ff.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vlsseg2e16.c | 40 +++++++------- .../policy_funcs/gnu-api-tests/vlsseg3e16.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vlsseg4e16.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vlsseg5e16.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vlsseg6e16.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vlsseg7e16.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vlsseg8e16.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vluxei16.c | 48 ++++++++--------- .../policy_funcs/gnu-api-tests/vluxei32.c | 40 +++++++------- .../policy_funcs/gnu-api-tests/vluxei64.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vluxei8.c | 48 ++++++++--------- .../policy_funcs/gnu-api-tests/vluxseg2ei16.c | 40 +++++++------- .../policy_funcs/gnu-api-tests/vluxseg2ei32.c | 40 +++++++------- .../policy_funcs/gnu-api-tests/vluxseg2ei64.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vluxseg2ei8.c | 40 +++++++------- .../policy_funcs/gnu-api-tests/vluxseg3ei16.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vluxseg3ei32.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vluxseg3ei64.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vluxseg3ei8.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vluxseg4ei16.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vluxseg4ei32.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vluxseg4ei64.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vluxseg4ei8.c | 32 ++++++------ .../policy_funcs/gnu-api-tests/vluxseg5ei16.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vluxseg5ei32.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vluxseg5ei64.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vluxseg5ei8.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vluxseg6ei16.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vluxseg6ei32.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vluxseg6ei64.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vluxseg6ei8.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vluxseg7ei16.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vluxseg7ei32.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vluxseg7ei64.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vluxseg7ei8.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vluxseg8ei16.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vluxseg8ei32.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vluxseg8ei64.c | 24 ++++----- .../policy_funcs/gnu-api-tests/vluxseg8ei8.c | 24 ++++----- .../policy_funcs/gnu-overloaded-tests/vle16.c | 48 ++++++++--------- .../gnu-overloaded-tests/vle16ff.c | 48 ++++++++--------- .../gnu-overloaded-tests/vloxei16.c | 48 ++++++++--------- .../gnu-overloaded-tests/vloxei32.c | 40 +++++++------- .../gnu-overloaded-tests/vloxei64.c | 32 ++++++------ .../gnu-overloaded-tests/vloxei8.c | 48 ++++++++--------- .../gnu-overloaded-tests/vloxseg2ei16.c | 40 +++++++------- .../gnu-overloaded-tests/vloxseg2ei32.c | 40 +++++++------- .../gnu-overloaded-tests/vloxseg2ei64.c | 32 ++++++------ .../gnu-overloaded-tests/vloxseg2ei8.c | 40 +++++++------- .../gnu-overloaded-tests/vloxseg3ei16.c | 32 ++++++------ .../gnu-overloaded-tests/vloxseg3ei32.c | 32 ++++++------ .../gnu-overloaded-tests/vloxseg3ei64.c | 32 ++++++------ .../gnu-overloaded-tests/vloxseg3ei8.c | 32 ++++++------ .../gnu-overloaded-tests/vloxseg4ei16.c | 32 ++++++------ .../gnu-overloaded-tests/vloxseg4ei32.c | 32 ++++++------ .../gnu-overloaded-tests/vloxseg4ei64.c | 32 ++++++------ .../gnu-overloaded-tests/vloxseg4ei8.c | 32 ++++++------ .../gnu-overloaded-tests/vloxseg5ei16.c | 24 ++++----- .../gnu-overloaded-tests/vloxseg5ei32.c | 24 ++++----- .../gnu-overloaded-tests/vloxseg5ei64.c | 24 ++++----- .../gnu-overloaded-tests/vloxseg5ei8.c | 24 ++++----- .../gnu-overloaded-tests/vloxseg6ei16.c | 24 ++++----- .../gnu-overloaded-tests/vloxseg6ei32.c | 24 ++++----- .../gnu-overloaded-tests/vloxseg6ei64.c | 24 ++++----- .../gnu-overloaded-tests/vloxseg6ei8.c | 24 ++++----- .../gnu-overloaded-tests/vloxseg7ei16.c | 24 ++++----- .../gnu-overloaded-tests/vloxseg7ei32.c | 24 ++++----- .../gnu-overloaded-tests/vloxseg7ei64.c | 24 ++++----- .../gnu-overloaded-tests/vloxseg7ei8.c | 24 ++++----- .../gnu-overloaded-tests/vloxseg8ei16.c | 24 ++++----- .../gnu-overloaded-tests/vloxseg8ei32.c | 24 ++++----- .../gnu-overloaded-tests/vloxseg8ei64.c | 24 ++++----- .../gnu-overloaded-tests/vloxseg8ei8.c | 24 ++++----- .../gnu-overloaded-tests/vlse16.c | 48 ++++++++--------- .../gnu-overloaded-tests/vlseg2e16.c | 40 +++++++------- .../gnu-overloaded-tests/vlseg2e16ff.c | 40 +++++++------- .../gnu-overloaded-tests/vlseg3e16.c | 32 ++++++------ .../gnu-overloaded-tests/vlseg3e16ff.c | 32 ++++++------ .../gnu-overloaded-tests/vlseg4e16.c | 32 ++++++------ .../gnu-overloaded-tests/vlseg4e16ff.c | 32 ++++++------ .../gnu-overloaded-tests/vlseg5e16.c | 24 ++++----- .../gnu-overloaded-tests/vlseg5e16ff.c | 24 ++++----- .../gnu-overloaded-tests/vlseg6e16.c | 24 ++++----- .../gnu-overloaded-tests/vlseg6e16ff.c | 24 ++++----- .../gnu-overloaded-tests/vlseg7e16.c | 24 ++++----- .../gnu-overloaded-tests/vlseg7e16ff.c | 24 ++++----- .../gnu-overloaded-tests/vlseg8e16.c | 24 ++++----- .../gnu-overloaded-tests/vlseg8e16ff.c | 24 ++++----- .../gnu-overloaded-tests/vlsseg2e16.c | 40 +++++++------- .../gnu-overloaded-tests/vlsseg3e16.c | 32 ++++++------ .../gnu-overloaded-tests/vlsseg4e16.c | 32 ++++++------ .../gnu-overloaded-tests/vlsseg5e16.c | 24 ++++----- .../gnu-overloaded-tests/vlsseg6e16.c | 24 ++++----- .../gnu-overloaded-tests/vlsseg7e16.c | 24 ++++----- .../gnu-overloaded-tests/vlsseg8e16.c | 24 ++++----- .../gnu-overloaded-tests/vluxei16.c | 48 ++++++++--------- .../gnu-overloaded-tests/vluxei32.c | 40 +++++++------- .../gnu-overloaded-tests/vluxei64.c | 32 ++++++------ .../gnu-overloaded-tests/vluxei8.c | 48 ++++++++--------- .../gnu-overloaded-tests/vluxseg2ei16.c | 40 +++++++------- .../gnu-overloaded-tests/vluxseg2ei32.c | 40 +++++++------- .../gnu-overloaded-tests/vluxseg2ei64.c | 32 ++++++------ .../gnu-overloaded-tests/vluxseg2ei8.c | 40 +++++++------- .../gnu-overloaded-tests/vluxseg3ei16.c | 32 ++++++------ .../gnu-overloaded-tests/vluxseg3ei32.c | 32 ++++++------ .../gnu-overloaded-tests/vluxseg3ei64.c | 32 ++++++------ .../gnu-overloaded-tests/vluxseg3ei8.c | 32 ++++++------ .../gnu-overloaded-tests/vluxseg4ei16.c | 32 ++++++------ .../gnu-overloaded-tests/vluxseg4ei32.c | 32 ++++++------ .../gnu-overloaded-tests/vluxseg4ei64.c | 32 ++++++------ .../gnu-overloaded-tests/vluxseg4ei8.c | 32 ++++++------ .../gnu-overloaded-tests/vluxseg5ei16.c | 24 ++++----- .../gnu-overloaded-tests/vluxseg5ei32.c | 24 ++++----- .../gnu-overloaded-tests/vluxseg5ei64.c | 24 ++++----- .../gnu-overloaded-tests/vluxseg5ei8.c | 24 ++++----- .../gnu-overloaded-tests/vluxseg6ei16.c | 24 ++++----- .../gnu-overloaded-tests/vluxseg6ei32.c | 24 ++++----- .../gnu-overloaded-tests/vluxseg6ei64.c | 24 ++++----- .../gnu-overloaded-tests/vluxseg6ei8.c | 24 ++++----- .../gnu-overloaded-tests/vluxseg7ei16.c | 24 ++++----- .../gnu-overloaded-tests/vluxseg7ei32.c | 24 ++++----- .../gnu-overloaded-tests/vluxseg7ei64.c | 24 ++++----- .../gnu-overloaded-tests/vluxseg7ei8.c | 24 ++++----- .../gnu-overloaded-tests/vluxseg8ei16.c | 24 ++++----- .../gnu-overloaded-tests/vluxseg8ei32.c | 24 ++++----- .../gnu-overloaded-tests/vluxseg8ei64.c | 24 ++++----- .../gnu-overloaded-tests/vluxseg8ei8.c | 24 ++++----- .../overloaded-api-testing/vle16.c | 48 ++++++++--------- .../overloaded-api-testing/vle16ff.c | 48 ++++++++--------- .../overloaded-api-testing/vloxei16.c | 52 +++++++++---------- .../overloaded-api-testing/vloxei32.c | 42 +++++++-------- .../overloaded-api-testing/vloxei64.c | 32 ++++++------ .../overloaded-api-testing/vloxei8.c | 48 ++++++++--------- .../overloaded-api-testing/vloxseg2ei16.c | 40 +++++++------- .../overloaded-api-testing/vloxseg2ei32.c | 40 +++++++------- .../overloaded-api-testing/vloxseg2ei64.c | 32 ++++++------ .../overloaded-api-testing/vloxseg2ei8.c | 40 +++++++------- .../overloaded-api-testing/vloxseg3ei16.c | 32 ++++++------ .../overloaded-api-testing/vloxseg3ei32.c | 32 ++++++------ .../overloaded-api-testing/vloxseg3ei64.c | 32 ++++++------ .../overloaded-api-testing/vloxseg3ei8.c | 32 ++++++------ .../overloaded-api-testing/vloxseg4ei16.c | 32 ++++++------ .../overloaded-api-testing/vloxseg4ei32.c | 32 ++++++------ .../overloaded-api-testing/vloxseg4ei64.c | 32 ++++++------ .../overloaded-api-testing/vloxseg4ei8.c | 32 ++++++------ .../overloaded-api-testing/vloxseg5ei16.c | 24 ++++----- .../overloaded-api-testing/vloxseg5ei32.c | 24 ++++----- .../overloaded-api-testing/vloxseg5ei64.c | 24 ++++----- .../overloaded-api-testing/vloxseg5ei8.c | 24 ++++----- .../overloaded-api-testing/vloxseg6ei16.c | 24 ++++----- .../overloaded-api-testing/vloxseg6ei32.c | 24 ++++----- .../overloaded-api-testing/vloxseg6ei64.c | 24 ++++----- .../overloaded-api-testing/vloxseg6ei8.c | 24 ++++----- .../overloaded-api-testing/vloxseg7ei16.c | 24 ++++----- .../overloaded-api-testing/vloxseg7ei32.c | 24 ++++----- .../overloaded-api-testing/vloxseg7ei64.c | 24 ++++----- .../overloaded-api-testing/vloxseg7ei8.c | 24 ++++----- .../overloaded-api-testing/vloxseg8ei16.c | 24 ++++----- .../overloaded-api-testing/vloxseg8ei32.c | 24 ++++----- .../overloaded-api-testing/vloxseg8ei64.c | 24 ++++----- .../overloaded-api-testing/vloxseg8ei8.c | 24 ++++----- .../overloaded-api-testing/vlse16.c | 48 ++++++++--------- .../overloaded-api-testing/vlseg2e16.c | 42 +++++++-------- .../overloaded-api-testing/vlseg2e16ff.c | 40 +++++++------- .../overloaded-api-testing/vlseg3e16.c | 34 ++++++------ .../overloaded-api-testing/vlseg3e16ff.c | 32 ++++++------ .../overloaded-api-testing/vlseg4e16.c | 34 ++++++------ .../overloaded-api-testing/vlseg4e16ff.c | 32 ++++++------ .../overloaded-api-testing/vlseg5e16.c | 26 +++++----- .../overloaded-api-testing/vlseg5e16ff.c | 24 ++++----- .../overloaded-api-testing/vlseg6e16.c | 26 +++++----- .../overloaded-api-testing/vlseg6e16ff.c | 24 ++++----- .../overloaded-api-testing/vlseg7e16.c | 26 +++++----- .../overloaded-api-testing/vlseg7e16ff.c | 24 ++++----- .../overloaded-api-testing/vlseg8e16.c | 26 +++++----- .../overloaded-api-testing/vlseg8e16ff.c | 24 ++++----- .../overloaded-api-testing/vlsseg2e16.c | 46 ++++++++-------- .../overloaded-api-testing/vlsseg3e16.c | 36 ++++++------- .../overloaded-api-testing/vlsseg4e16.c | 36 ++++++------- .../overloaded-api-testing/vlsseg5e16.c | 26 +++++----- .../overloaded-api-testing/vlsseg6e16.c | 26 +++++----- .../overloaded-api-testing/vlsseg7e16.c | 26 +++++----- .../overloaded-api-testing/vlsseg8e16.c | 26 +++++----- .../overloaded-api-testing/vluxei16.c | 52 +++++++++---------- .../overloaded-api-testing/vluxei32.c | 42 +++++++-------- .../overloaded-api-testing/vluxei64.c | 32 ++++++------ .../overloaded-api-testing/vluxei8.c | 48 ++++++++--------- .../overloaded-api-testing/vluxseg2ei16.c | 40 +++++++------- .../overloaded-api-testing/vluxseg2ei32.c | 40 +++++++------- .../overloaded-api-testing/vluxseg2ei64.c | 32 ++++++------ .../overloaded-api-testing/vluxseg2ei8.c | 40 +++++++------- .../overloaded-api-testing/vluxseg3ei16.c | 32 ++++++------ .../overloaded-api-testing/vluxseg3ei32.c | 32 ++++++------ .../overloaded-api-testing/vluxseg3ei64.c | 32 ++++++------ .../overloaded-api-testing/vluxseg3ei8.c | 32 ++++++------ .../overloaded-api-testing/vluxseg4ei16.c | 32 ++++++------ .../overloaded-api-testing/vluxseg4ei32.c | 32 ++++++------ .../overloaded-api-testing/vluxseg4ei64.c | 32 ++++++------ .../overloaded-api-testing/vluxseg4ei8.c | 32 ++++++------ .../overloaded-api-testing/vluxseg5ei16.c | 24 ++++----- .../overloaded-api-testing/vluxseg5ei32.c | 24 ++++----- .../overloaded-api-testing/vluxseg5ei64.c | 24 ++++----- .../overloaded-api-testing/vluxseg5ei8.c | 24 ++++----- .../overloaded-api-testing/vluxseg6ei16.c | 24 ++++----- .../overloaded-api-testing/vluxseg6ei32.c | 24 ++++----- .../overloaded-api-testing/vluxseg6ei64.c | 24 ++++----- .../overloaded-api-testing/vluxseg6ei8.c | 24 ++++----- .../overloaded-api-testing/vluxseg7ei16.c | 24 ++++----- .../overloaded-api-testing/vluxseg7ei32.c | 24 ++++----- .../overloaded-api-testing/vluxseg7ei64.c | 24 ++++----- .../overloaded-api-testing/vluxseg7ei8.c | 24 ++++----- .../overloaded-api-testing/vluxseg8ei16.c | 24 ++++----- .../overloaded-api-testing/vluxseg8ei32.c | 24 ++++----- .../overloaded-api-testing/vluxseg8ei64.c | 24 ++++----- .../overloaded-api-testing/vluxseg8ei8.c | 24 ++++----- 1024 files changed, 10574 insertions(+), 10832 deletions(-) diff --git a/auto-generated/api-testing/vle16.c b/auto-generated/api-testing/vle16.c index 05ec61263..34d682830 100644 --- a/auto-generated/api-testing/vle16.c +++ b/auto-generated/api-testing/vle16.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vle16_v_f16mf4(const float16_t *rs1, size_t vl) { +vfloat16mf4_t test_vle16_v_f16mf4(const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf4(rs1, vl); } -vfloat16mf2_t test_vle16_v_f16mf2(const float16_t *rs1, size_t vl) { +vfloat16mf2_t test_vle16_v_f16mf2(const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf2(rs1, vl); } -vfloat16m1_t test_vle16_v_f16m1(const float16_t *rs1, size_t vl) { +vfloat16m1_t test_vle16_v_f16m1(const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m1(rs1, vl); } -vfloat16m2_t test_vle16_v_f16m2(const float16_t *rs1, size_t vl) { +vfloat16m2_t test_vle16_v_f16m2(const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m2(rs1, vl); } -vfloat16m4_t test_vle16_v_f16m4(const float16_t *rs1, size_t vl) { +vfloat16m4_t test_vle16_v_f16m4(const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m4(rs1, vl); } -vfloat16m8_t test_vle16_v_f16m8(const float16_t *rs1, size_t vl) { +vfloat16m8_t test_vle16_v_f16m8(const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m8(rs1, vl); } @@ -77,33 +77,30 @@ vuint16m8_t test_vle16_v_u16m8(const uint16_t *rs1, size_t vl) { return __riscv_vle16_v_u16m8(rs1, vl); } -vfloat16mf4_t test_vle16_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vle16_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf4_m(vm, rs1, vl); } -vfloat16mf2_t test_vle16_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vle16_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf2_m(vm, rs1, vl); } -vfloat16m1_t test_vle16_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vle16_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m1_m(vm, rs1, vl); } -vfloat16m2_t test_vle16_v_f16m2_m(vbool8_t vm, const float16_t *rs1, - size_t vl) { +vfloat16m2_t test_vle16_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m2_m(vm, rs1, vl); } -vfloat16m4_t test_vle16_v_f16m4_m(vbool4_t vm, const float16_t *rs1, - size_t vl) { +vfloat16m4_t test_vle16_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m4_m(vm, rs1, vl); } -vfloat16m8_t test_vle16_v_f16m8_m(vbool2_t vm, const float16_t *rs1, - size_t vl) { +vfloat16m8_t test_vle16_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m8_m(vm, rs1, vl); } diff --git a/auto-generated/api-testing/vle16ff.c b/auto-generated/api-testing/vle16ff.c index 42a36efee..2b869e460 100644 --- a/auto-generated/api-testing/vle16ff.c +++ b/auto-generated/api-testing/vle16ff.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vle16ff_v_f16mf4(const float16_t *rs1, size_t *new_vl, +vfloat16mf4_t test_vle16ff_v_f16mf4(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf4(rs1, new_vl, vl); } -vfloat16mf2_t test_vle16ff_v_f16mf2(const float16_t *rs1, size_t *new_vl, +vfloat16mf2_t test_vle16ff_v_f16mf2(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf2(rs1, new_vl, vl); } -vfloat16m1_t test_vle16ff_v_f16m1(const float16_t *rs1, size_t *new_vl, +vfloat16m1_t test_vle16ff_v_f16m1(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m1(rs1, new_vl, vl); } -vfloat16m2_t test_vle16ff_v_f16m2(const float16_t *rs1, size_t *new_vl, +vfloat16m2_t test_vle16ff_v_f16m2(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m2(rs1, new_vl, vl); } -vfloat16m4_t test_vle16ff_v_f16m4(const float16_t *rs1, size_t *new_vl, +vfloat16m4_t test_vle16ff_v_f16m4(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m4(rs1, new_vl, vl); } -vfloat16m8_t test_vle16ff_v_f16m8(const float16_t *rs1, size_t *new_vl, +vfloat16m8_t test_vle16ff_v_f16m8(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m8(rs1, new_vl, vl); } @@ -91,32 +91,32 @@ vuint16m8_t test_vle16ff_v_u16m8(const uint16_t *rs1, size_t *new_vl, return __riscv_vle16ff_v_u16m8(rs1, new_vl, vl); } -vfloat16mf4_t test_vle16ff_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vle16ff_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf4_m(vm, rs1, new_vl, vl); } -vfloat16mf2_t test_vle16ff_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vle16ff_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf2_m(vm, rs1, new_vl, vl); } -vfloat16m1_t test_vle16ff_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vle16ff_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m1_m(vm, rs1, new_vl, vl); } -vfloat16m2_t test_vle16ff_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vle16ff_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m2_m(vm, rs1, new_vl, vl); } -vfloat16m4_t test_vle16ff_v_f16m4_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4_t test_vle16ff_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m4_m(vm, rs1, new_vl, vl); } -vfloat16m8_t test_vle16ff_v_f16m8_m(vbool2_t vm, const float16_t *rs1, +vfloat16m8_t test_vle16ff_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m8_m(vm, rs1, new_vl, vl); } diff --git a/auto-generated/api-testing/vloxei16.c b/auto-generated/api-testing/vloxei16.c index 55cad9a07..107a585f9 100644 --- a/auto-generated/api-testing/vloxei16.c +++ b/auto-generated/api-testing/vloxei16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei16_v_f16mf4(const float16_t *rs1, vuint16mf4_t rs2, +vfloat16mf4_t test_vloxei16_v_f16mf4(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2(const float16_t *rs1, vuint16mf2_t rs2, +vfloat16mf2_t test_vloxei16_v_f16mf2(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1(const float16_t *rs1, vuint16m1_t rs2, +vfloat16m1_t test_vloxei16_v_f16m1(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2(const float16_t *rs1, vuint16m2_t rs2, +vfloat16m2_t test_vloxei16_v_f16m2(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m2(rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4(const float16_t *rs1, vuint16m4_t rs2, +vfloat16m4_t test_vloxei16_v_f16m4(const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m4(rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8(const float16_t *rs1, vuint16m8_t rs2, +vfloat16m8_t test_vloxei16_v_f16m8(const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m8(rs1, rs2, vl); } @@ -287,32 +287,32 @@ vuint64m8_t test_vloxei16_v_u64m8(const uint64_t *rs1, vuint16m2_t rs2, return __riscv_vloxei16_v_u64m8(rs1, rs2, vl); } -vfloat16mf4_t test_vloxei16_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vloxei16_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vloxei16_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vloxei16_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vloxei16_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m2_m(vm, rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4_t test_vloxei16_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m4_m(vm, rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8_m(vbool2_t vm, const float16_t *rs1, +vfloat16m8_t test_vloxei16_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxei32.c b/auto-generated/api-testing/vloxei32.c index 616405d47..72fd61841 100644 --- a/auto-generated/api-testing/vloxei32.c +++ b/auto-generated/api-testing/vloxei32.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei32_v_f16mf4(const float16_t *rs1, vuint32mf2_t rs2, +vfloat16mf4_t test_vloxei32_v_f16mf4(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2(const float16_t *rs1, vuint32m1_t rs2, +vfloat16mf2_t test_vloxei32_v_f16mf2(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1(const float16_t *rs1, vuint32m2_t rs2, +vfloat16m1_t test_vloxei32_v_f16m1(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2(const float16_t *rs1, vuint32m4_t rs2, +vfloat16m2_t test_vloxei32_v_f16m2(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m2(rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4(const float16_t *rs1, vuint32m8_t rs2, +vfloat16m4_t test_vloxei32_v_f16m4(const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m4(rs1, rs2, vl); } @@ -263,27 +263,27 @@ vuint64m8_t test_vloxei32_v_u64m8(const uint64_t *rs1, vuint32m4_t rs2, return __riscv_vloxei32_v_u64m8(rs1, rs2, vl); } -vfloat16mf4_t test_vloxei32_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vloxei32_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vloxei32_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vloxei32_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vloxei32_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m2_m(vm, rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4_t test_vloxei32_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxei64.c b/auto-generated/api-testing/vloxei64.c index 9d1235a3f..c7a12a33c 100644 --- a/auto-generated/api-testing/vloxei64.c +++ b/auto-generated/api-testing/vloxei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei64_v_f16mf4(const float16_t *rs1, vuint64m1_t rs2, +vfloat16mf4_t test_vloxei64_v_f16mf4(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2(const float16_t *rs1, vuint64m2_t rs2, +vfloat16mf2_t test_vloxei64_v_f16mf2(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1(const float16_t *rs1, vuint64m4_t rs2, +vfloat16m1_t test_vloxei64_v_f16m1(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2(const float16_t *rs1, vuint64m8_t rs2, +vfloat16m2_t test_vloxei64_v_f16m2(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m2(rs1, rs2, vl); } @@ -224,22 +224,22 @@ vuint64m8_t test_vloxei64_v_u64m8(const uint64_t *rs1, vuint64m8_t rs2, return __riscv_vloxei64_v_u64m8(rs1, rs2, vl); } -vfloat16mf4_t test_vloxei64_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vloxei64_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vloxei64_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vloxei64_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vloxei64_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxei8.c b/auto-generated/api-testing/vloxei8.c index c03d8a52c..a9a00a387 100644 --- a/auto-generated/api-testing/vloxei8.c +++ b/auto-generated/api-testing/vloxei8.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei8_v_f16mf4(const float16_t *rs1, vuint8mf8_t rs2, +vfloat16mf4_t test_vloxei8_v_f16mf4(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2(const float16_t *rs1, vuint8mf4_t rs2, +vfloat16mf2_t test_vloxei8_v_f16mf2(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1_t test_vloxei8_v_f16m1(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2(const float16_t *rs1, vuint8m1_t rs2, +vfloat16m2_t test_vloxei8_v_f16m2(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m2(rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4(const float16_t *rs1, vuint8m2_t rs2, +vfloat16m4_t test_vloxei8_v_f16m4(const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m4(rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8(const float16_t *rs1, vuint8m4_t rs2, +vfloat16m8_t test_vloxei8_v_f16m8(const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m8(rs1, rs2, vl); } @@ -283,32 +283,32 @@ vuint64m8_t test_vloxei8_v_u64m8(const uint64_t *rs1, vuint8m1_t rs2, return __riscv_vloxei8_v_u64m8(rs1, rs2, vl); } -vfloat16mf4_t test_vloxei8_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vloxei8_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vloxei8_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vloxei8_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vloxei8_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m2_m(vm, rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4_t test_vloxei8_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m4_m(vm, rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8_m(vbool2_t vm, const float16_t *rs1, +vfloat16m8_t test_vloxei8_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg2ei16.c b/auto-generated/api-testing/vloxseg2ei16.c index 72441d0e5..46610d04f 100644 --- a/auto-generated/api-testing/vloxseg2ei16.c +++ b/auto-generated/api-testing/vloxseg2ei16.c @@ -5,28 +5,28 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2(const float16_t *rs1, +vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2(const float16_t *rs1, +vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vloxseg2ei16_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2(const float16_t *rs1, - vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2(const _Float16 *rs1, vuint16m2_t rs2, + size_t vl) { return __riscv_vloxseg2ei16_v_f16m2x2(rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2(const float16_t *rs1, - vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2(const _Float16 *rs1, vuint16m4_t rs2, + size_t vl) { return __riscv_vloxseg2ei16_v_f16m4x2(rs1, rs2, vl); } @@ -246,28 +246,28 @@ vuint64m4x2_t test_vloxseg2ei16_v_u64m4x2(const uint64_t *rs1, vuint16m1_t rs2, } vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf4x2_m(vm, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m2x2_m(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m4x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg2ei32.c b/auto-generated/api-testing/vloxseg2ei32.c index 1c7b1f130..4f7ca1f84 100644 --- a/auto-generated/api-testing/vloxseg2ei32.c +++ b/auto-generated/api-testing/vloxseg2ei32.c @@ -5,28 +5,28 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2(const float16_t *rs1, +vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2(const float16_t *rs1, +vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vloxseg2ei32_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2(const float16_t *rs1, - vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2(const _Float16 *rs1, vuint32m4_t rs2, + size_t vl) { return __riscv_vloxseg2ei32_v_f16m2x2(rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2(const float16_t *rs1, - vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2(const _Float16 *rs1, vuint32m8_t rs2, + size_t vl) { return __riscv_vloxseg2ei32_v_f16m4x2(rs1, rs2, vl); } @@ -236,28 +236,28 @@ vuint64m4x2_t test_vloxseg2ei32_v_u64m4x2(const uint64_t *rs1, vuint32m2_t rs2, } vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf4x2_m(vm, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m2x2_m(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m4x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg2ei64.c b/auto-generated/api-testing/vloxseg2ei64.c index f08e122c0..abdbd03b7 100644 --- a/auto-generated/api-testing/vloxseg2ei64.c +++ b/auto-generated/api-testing/vloxseg2ei64.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2(const float16_t *rs1, +vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2(const float16_t *rs1, +vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vloxseg2ei64_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2(const float16_t *rs1, - vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2(const _Float16 *rs1, vuint64m8_t rs2, + size_t vl) { return __riscv_vloxseg2ei64_v_f16m2x2(rs1, rs2, vl); } @@ -211,23 +211,23 @@ vuint64m4x2_t test_vloxseg2ei64_v_u64m4x2(const uint64_t *rs1, vuint64m4_t rs2, } vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf4x2_m(vm, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m2x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg2ei8.c b/auto-generated/api-testing/vloxseg2ei8.c index 4b544d21f..a2d7fbc06 100644 --- a/auto-generated/api-testing/vloxseg2ei8.c +++ b/auto-generated/api-testing/vloxseg2ei8.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2(const float16_t *rs1, +vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2(const float16_t *rs1, +vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2(const float16_t *rs1, vuint8m1_t rs2, +vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m2x2(rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2(const float16_t *rs1, vuint8m2_t rs2, +vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2(const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m4x2(rs1, rs2, vl); } @@ -245,29 +245,27 @@ vuint64m4x2_t test_vloxseg2ei8_v_u64m4x2(const uint64_t *rs1, vuint8mf2_t rs2, return __riscv_vloxseg2ei8_v_u64m4x2(rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf4x2_m(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m2x2_m(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m4x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg3ei16.c b/auto-generated/api-testing/vloxseg3ei16.c index b4e32f5b2..f946eb81f 100644 --- a/auto-generated/api-testing/vloxseg3ei16.c +++ b/auto-generated/api-testing/vloxseg3ei16.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3(const float16_t *rs1, +vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3(const float16_t *rs1, +vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vloxseg3ei16_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3(const float16_t *rs1, - vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3(const _Float16 *rs1, vuint16m2_t rs2, + size_t vl) { return __riscv_vloxseg3ei16_v_f16m2x3(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m2x3_t test_vloxseg3ei16_v_u64m2x3(const uint64_t *rs1, vuint16mf2_t rs2, } vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf4x3_m(vm, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg3ei32.c b/auto-generated/api-testing/vloxseg3ei32.c index b6343f767..505debe9e 100644 --- a/auto-generated/api-testing/vloxseg3ei32.c +++ b/auto-generated/api-testing/vloxseg3ei32.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3(const float16_t *rs1, +vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3(const float16_t *rs1, +vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vloxseg3ei32_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3(const float16_t *rs1, - vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3(const _Float16 *rs1, vuint32m4_t rs2, + size_t vl) { return __riscv_vloxseg3ei32_v_f16m2x3(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m2x3_t test_vloxseg3ei32_v_u64m2x3(const uint64_t *rs1, vuint32m1_t rs2, } vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf4x3_m(vm, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg3ei64.c b/auto-generated/api-testing/vloxseg3ei64.c index 9df81f16f..0be385499 100644 --- a/auto-generated/api-testing/vloxseg3ei64.c +++ b/auto-generated/api-testing/vloxseg3ei64.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3(const float16_t *rs1, +vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3(const float16_t *rs1, +vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vloxseg3ei64_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3(const float16_t *rs1, - vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3(const _Float16 *rs1, vuint64m8_t rs2, + size_t vl) { return __riscv_vloxseg3ei64_v_f16m2x3(rs1, rs2, vl); } @@ -181,23 +181,23 @@ vuint64m2x3_t test_vloxseg3ei64_v_u64m2x3(const uint64_t *rs1, vuint64m2_t rs2, } vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf4x3_m(vm, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg3ei8.c b/auto-generated/api-testing/vloxseg3ei8.c index 879d71d2b..3b4f02454 100644 --- a/auto-generated/api-testing/vloxseg3ei8.c +++ b/auto-generated/api-testing/vloxseg3ei8.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3(const float16_t *rs1, +vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3(const float16_t *rs1, +vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3(const float16_t *rs1, vuint8m1_t rs2, +vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m2x3(rs1, rs2, vl); } @@ -190,24 +190,22 @@ vuint64m2x3_t test_vloxseg3ei8_v_u64m2x3(const uint64_t *rs1, vuint8mf4_t rs2, return __riscv_vloxseg3ei8_v_u64m2x3(rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf4x3_m(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg4ei16.c b/auto-generated/api-testing/vloxseg4ei16.c index d6dabde4f..fb89fd2bc 100644 --- a/auto-generated/api-testing/vloxseg4ei16.c +++ b/auto-generated/api-testing/vloxseg4ei16.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4(const float16_t *rs1, +vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4(const float16_t *rs1, +vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vloxseg4ei16_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4(const float16_t *rs1, - vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4(const _Float16 *rs1, vuint16m2_t rs2, + size_t vl) { return __riscv_vloxseg4ei16_v_f16m2x4(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m2x4_t test_vloxseg4ei16_v_u64m2x4(const uint64_t *rs1, vuint16mf2_t rs2, } vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf4x4_m(vm, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg4ei32.c b/auto-generated/api-testing/vloxseg4ei32.c index 1122fede8..906d53e37 100644 --- a/auto-generated/api-testing/vloxseg4ei32.c +++ b/auto-generated/api-testing/vloxseg4ei32.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4(const float16_t *rs1, +vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4(const float16_t *rs1, +vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vloxseg4ei32_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4(const float16_t *rs1, - vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4(const _Float16 *rs1, vuint32m4_t rs2, + size_t vl) { return __riscv_vloxseg4ei32_v_f16m2x4(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m2x4_t test_vloxseg4ei32_v_u64m2x4(const uint64_t *rs1, vuint32m1_t rs2, } vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf4x4_m(vm, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg4ei64.c b/auto-generated/api-testing/vloxseg4ei64.c index a9268ba6d..f38b37996 100644 --- a/auto-generated/api-testing/vloxseg4ei64.c +++ b/auto-generated/api-testing/vloxseg4ei64.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4(const float16_t *rs1, +vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4(const float16_t *rs1, +vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vloxseg4ei64_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4(const float16_t *rs1, - vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4(const _Float16 *rs1, vuint64m8_t rs2, + size_t vl) { return __riscv_vloxseg4ei64_v_f16m2x4(rs1, rs2, vl); } @@ -181,23 +181,23 @@ vuint64m2x4_t test_vloxseg4ei64_v_u64m2x4(const uint64_t *rs1, vuint64m2_t rs2, } vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf4x4_m(vm, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg4ei8.c b/auto-generated/api-testing/vloxseg4ei8.c index cc1670041..5cd7b5f50 100644 --- a/auto-generated/api-testing/vloxseg4ei8.c +++ b/auto-generated/api-testing/vloxseg4ei8.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4(const float16_t *rs1, +vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4(const float16_t *rs1, +vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4(const float16_t *rs1, vuint8m1_t rs2, +vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m2x4(rs1, rs2, vl); } @@ -190,24 +190,22 @@ vuint64m2x4_t test_vloxseg4ei8_v_u64m2x4(const uint64_t *rs1, vuint8mf4_t rs2, return __riscv_vloxseg4ei8_v_u64m2x4(rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf4x4_m(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg5ei16.c b/auto-generated/api-testing/vloxseg5ei16.c index b6879d268..3a64fdfc7 100644 --- a/auto-generated/api-testing/vloxseg5ei16.c +++ b/auto-generated/api-testing/vloxseg5ei16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5(const float16_t *rs1, +vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5(const float16_t *rs1, +vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vloxseg5ei16_v_f16m1x5(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x5_t test_vloxseg5ei16_v_u64m1x5(const uint64_t *rs1, vuint16mf4_t rs2, } vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf4x5_m(vm, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg5ei32.c b/auto-generated/api-testing/vloxseg5ei32.c index 96d39b88c..6e79446a0 100644 --- a/auto-generated/api-testing/vloxseg5ei32.c +++ b/auto-generated/api-testing/vloxseg5ei32.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5(const float16_t *rs1, +vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5(const float16_t *rs1, +vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vloxseg5ei32_v_f16m1x5(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x5_t test_vloxseg5ei32_v_u64m1x5(const uint64_t *rs1, vuint32mf2_t rs2, } vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf4x5_m(vm, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg5ei64.c b/auto-generated/api-testing/vloxseg5ei64.c index e078039fb..a07c35610 100644 --- a/auto-generated/api-testing/vloxseg5ei64.c +++ b/auto-generated/api-testing/vloxseg5ei64.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5(const float16_t *rs1, +vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5(const float16_t *rs1, +vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vloxseg5ei64_v_f16m1x5(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x5_t test_vloxseg5ei64_v_u64m1x5(const uint64_t *rs1, vuint64m1_t rs2, } vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf4x5_m(vm, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg5ei8.c b/auto-generated/api-testing/vloxseg5ei8.c index a88794038..9cc7b4ded 100644 --- a/auto-generated/api-testing/vloxseg5ei8.c +++ b/auto-generated/api-testing/vloxseg5ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5(const float16_t *rs1, +vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5(const float16_t *rs1, +vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16m1x5(rs1, rs2, vl); } @@ -135,19 +135,17 @@ vuint64m1x5_t test_vloxseg5ei8_v_u64m1x5(const uint64_t *rs1, vuint8mf8_t rs2, return __riscv_vloxseg5ei8_v_u64m1x5(rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf4x5_m(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg6ei16.c b/auto-generated/api-testing/vloxseg6ei16.c index 854c80e54..be4a01315 100644 --- a/auto-generated/api-testing/vloxseg6ei16.c +++ b/auto-generated/api-testing/vloxseg6ei16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6(const float16_t *rs1, +vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6(const float16_t *rs1, +vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vloxseg6ei16_v_f16m1x6(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x6_t test_vloxseg6ei16_v_u64m1x6(const uint64_t *rs1, vuint16mf4_t rs2, } vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf4x6_m(vm, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg6ei32.c b/auto-generated/api-testing/vloxseg6ei32.c index 92369be98..49f071069 100644 --- a/auto-generated/api-testing/vloxseg6ei32.c +++ b/auto-generated/api-testing/vloxseg6ei32.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6(const float16_t *rs1, +vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6(const float16_t *rs1, +vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vloxseg6ei32_v_f16m1x6(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x6_t test_vloxseg6ei32_v_u64m1x6(const uint64_t *rs1, vuint32mf2_t rs2, } vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf4x6_m(vm, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg6ei64.c b/auto-generated/api-testing/vloxseg6ei64.c index c3e31d09b..ab34c68f9 100644 --- a/auto-generated/api-testing/vloxseg6ei64.c +++ b/auto-generated/api-testing/vloxseg6ei64.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6(const float16_t *rs1, +vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6(const float16_t *rs1, +vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vloxseg6ei64_v_f16m1x6(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x6_t test_vloxseg6ei64_v_u64m1x6(const uint64_t *rs1, vuint64m1_t rs2, } vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf4x6_m(vm, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg6ei8.c b/auto-generated/api-testing/vloxseg6ei8.c index bf297827c..5c175c9d3 100644 --- a/auto-generated/api-testing/vloxseg6ei8.c +++ b/auto-generated/api-testing/vloxseg6ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6(const float16_t *rs1, +vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6(const float16_t *rs1, +vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16m1x6(rs1, rs2, vl); } @@ -135,19 +135,17 @@ vuint64m1x6_t test_vloxseg6ei8_v_u64m1x6(const uint64_t *rs1, vuint8mf8_t rs2, return __riscv_vloxseg6ei8_v_u64m1x6(rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf4x6_m(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg7ei16.c b/auto-generated/api-testing/vloxseg7ei16.c index 097c52e3b..3c04262af 100644 --- a/auto-generated/api-testing/vloxseg7ei16.c +++ b/auto-generated/api-testing/vloxseg7ei16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7(const float16_t *rs1, +vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7(const float16_t *rs1, +vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vloxseg7ei16_v_f16m1x7(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x7_t test_vloxseg7ei16_v_u64m1x7(const uint64_t *rs1, vuint16mf4_t rs2, } vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf4x7_m(vm, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg7ei32.c b/auto-generated/api-testing/vloxseg7ei32.c index 0340d0887..c52217455 100644 --- a/auto-generated/api-testing/vloxseg7ei32.c +++ b/auto-generated/api-testing/vloxseg7ei32.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7(const float16_t *rs1, +vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7(const float16_t *rs1, +vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vloxseg7ei32_v_f16m1x7(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x7_t test_vloxseg7ei32_v_u64m1x7(const uint64_t *rs1, vuint32mf2_t rs2, } vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf4x7_m(vm, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg7ei64.c b/auto-generated/api-testing/vloxseg7ei64.c index a4fb533ab..35892882b 100644 --- a/auto-generated/api-testing/vloxseg7ei64.c +++ b/auto-generated/api-testing/vloxseg7ei64.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7(const float16_t *rs1, +vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7(const float16_t *rs1, +vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vloxseg7ei64_v_f16m1x7(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x7_t test_vloxseg7ei64_v_u64m1x7(const uint64_t *rs1, vuint64m1_t rs2, } vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf4x7_m(vm, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg7ei8.c b/auto-generated/api-testing/vloxseg7ei8.c index 0304248c6..eb36de429 100644 --- a/auto-generated/api-testing/vloxseg7ei8.c +++ b/auto-generated/api-testing/vloxseg7ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7(const float16_t *rs1, +vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7(const float16_t *rs1, +vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16m1x7(rs1, rs2, vl); } @@ -135,19 +135,17 @@ vuint64m1x7_t test_vloxseg7ei8_v_u64m1x7(const uint64_t *rs1, vuint8mf8_t rs2, return __riscv_vloxseg7ei8_v_u64m1x7(rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf4x7_m(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg8ei16.c b/auto-generated/api-testing/vloxseg8ei16.c index b3c6f51d2..138ed9bde 100644 --- a/auto-generated/api-testing/vloxseg8ei16.c +++ b/auto-generated/api-testing/vloxseg8ei16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8(const float16_t *rs1, +vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8(const float16_t *rs1, +vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vloxseg8ei16_v_f16m1x8(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x8_t test_vloxseg8ei16_v_u64m1x8(const uint64_t *rs1, vuint16mf4_t rs2, } vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf4x8_m(vm, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg8ei32.c b/auto-generated/api-testing/vloxseg8ei32.c index 28a2399f2..7a5b77173 100644 --- a/auto-generated/api-testing/vloxseg8ei32.c +++ b/auto-generated/api-testing/vloxseg8ei32.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8(const float16_t *rs1, +vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8(const float16_t *rs1, +vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vloxseg8ei32_v_f16m1x8(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x8_t test_vloxseg8ei32_v_u64m1x8(const uint64_t *rs1, vuint32mf2_t rs2, } vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf4x8_m(vm, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg8ei64.c b/auto-generated/api-testing/vloxseg8ei64.c index 5c1df0521..63efaeaae 100644 --- a/auto-generated/api-testing/vloxseg8ei64.c +++ b/auto-generated/api-testing/vloxseg8ei64.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8(const float16_t *rs1, +vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8(const float16_t *rs1, +vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vloxseg8ei64_v_f16m1x8(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x8_t test_vloxseg8ei64_v_u64m1x8(const uint64_t *rs1, vuint64m1_t rs2, } vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf4x8_m(vm, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vloxseg8ei8.c b/auto-generated/api-testing/vloxseg8ei8.c index b94287a77..607ed506e 100644 --- a/auto-generated/api-testing/vloxseg8ei8.c +++ b/auto-generated/api-testing/vloxseg8ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8(const float16_t *rs1, +vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8(const float16_t *rs1, +vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16m1x8(rs1, rs2, vl); } @@ -135,19 +135,17 @@ vuint64m1x8_t test_vloxseg8ei8_v_u64m1x8(const uint64_t *rs1, vuint8mf8_t rs2, return __riscv_vloxseg8ei8_v_u64m1x8(rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf4x8_m(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vlse16.c b/auto-generated/api-testing/vlse16.c index 777d54201..7fa08327b 100644 --- a/auto-generated/api-testing/vlse16.c +++ b/auto-generated/api-testing/vlse16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vlse16_v_f16mf4(const float16_t *rs1, ptrdiff_t rs2, +vfloat16mf4_t test_vlse16_v_f16mf4(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vlse16_v_f16mf2(const float16_t *rs1, ptrdiff_t rs2, +vfloat16mf2_t test_vlse16_v_f16mf2(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vlse16_v_f16m1(const float16_t *rs1, ptrdiff_t rs2, +vfloat16m1_t test_vlse16_v_f16m1(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vlse16_v_f16m2(const float16_t *rs1, ptrdiff_t rs2, +vfloat16m2_t test_vlse16_v_f16m2(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m2(rs1, rs2, vl); } -vfloat16m4_t test_vlse16_v_f16m4(const float16_t *rs1, ptrdiff_t rs2, +vfloat16m4_t test_vlse16_v_f16m4(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m4(rs1, rs2, vl); } -vfloat16m8_t test_vlse16_v_f16m8(const float16_t *rs1, ptrdiff_t rs2, +vfloat16m8_t test_vlse16_v_f16m8(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m8(rs1, rs2, vl); } @@ -85,32 +85,32 @@ vuint16m8_t test_vlse16_v_u16m8(const uint16_t *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_u16m8(rs1, rs2, vl); } -vfloat16mf4_t test_vlse16_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vlse16_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vlse16_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vlse16_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vlse16_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vlse16_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vlse16_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vlse16_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m2_m(vm, rs1, rs2, vl); } -vfloat16m4_t test_vlse16_v_f16m4_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4_t test_vlse16_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m4_m(vm, rs1, rs2, vl); } -vfloat16m8_t test_vlse16_v_f16m8_m(vbool2_t vm, const float16_t *rs1, +vfloat16m8_t test_vlse16_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vlseg2e16.c b/auto-generated/api-testing/vlseg2e16.c index ea0d4d94f..f358000f7 100644 --- a/auto-generated/api-testing/vlseg2e16.c +++ b/auto-generated/api-testing/vlseg2e16.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2(const float16_t *rs1, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2(const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf4x2(rs1, vl); } -vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2(const float16_t *rs1, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2(const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf2x2(rs1, vl); } -vfloat16m1x2_t test_vlseg2e16_v_f16m1x2(const float16_t *rs1, size_t vl) { +vfloat16m1x2_t test_vlseg2e16_v_f16m1x2(const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m1x2(rs1, vl); } -vfloat16m2x2_t test_vlseg2e16_v_f16m2x2(const float16_t *rs1, size_t vl) { +vfloat16m2x2_t test_vlseg2e16_v_f16m2x2(const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m2x2(rs1, vl); } -vfloat16m4x2_t test_vlseg2e16_v_f16m4x2(const float16_t *rs1, size_t vl) { +vfloat16m4x2_t test_vlseg2e16_v_f16m4x2(const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m4x2(rs1, vl); } @@ -65,27 +65,27 @@ vuint16m4x2_t test_vlseg2e16_v_u16m4x2(const uint16_t *rs1, size_t vl) { return __riscv_vlseg2e16_v_u16m4x2(rs1, vl); } -vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf4x2_m(vm, rs1, vl); } -vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf2x2_m(vm, rs1, vl); } -vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m1x2_m(vm, rs1, vl); } -vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m2x2_m(vm, rs1, vl); } -vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m4x2_m(vm, rs1, vl); } diff --git a/auto-generated/api-testing/vlseg2e16ff.c b/auto-generated/api-testing/vlseg2e16ff.c index 1a48fb5dc..7dd20f2b3 100644 --- a/auto-generated/api-testing/vlseg2e16ff.c +++ b/auto-generated/api-testing/vlseg2e16ff.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2(const float16_t *rs1, - size_t *new_vl, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2(const _Float16 *rs1, size_t *new_vl, + size_t vl) { return __riscv_vlseg2e16ff_v_f16mf4x2(rs1, new_vl, vl); } -vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2(const float16_t *rs1, - size_t *new_vl, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2(const _Float16 *rs1, size_t *new_vl, + size_t vl) { return __riscv_vlseg2e16ff_v_f16mf2x2(rs1, new_vl, vl); } -vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2(const float16_t *rs1, size_t *new_vl, +vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m1x2(rs1, new_vl, vl); } -vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2(const float16_t *rs1, size_t *new_vl, +vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m2x2(rs1, new_vl, vl); } -vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2(const float16_t *rs1, size_t *new_vl, +vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m4x2(rs1, new_vl, vl); } @@ -80,29 +80,27 @@ vuint16m4x2_t test_vlseg2e16ff_v_u16m4x2(const uint16_t *rs1, size_t *new_vl, return __riscv_vlseg2e16ff_v_u16m4x2(rs1, new_vl, vl); } -vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf4x2_m(vm, rs1, new_vl, vl); } -vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf2x2_m(vm, rs1, new_vl, vl); } -vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m1x2_m(vm, rs1, new_vl, vl); } -vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m2x2_m(vm, rs1, new_vl, vl); } -vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m4x2_m(vm, rs1, new_vl, vl); } diff --git a/auto-generated/api-testing/vlseg3e16.c b/auto-generated/api-testing/vlseg3e16.c index b55e48bec..482911840 100644 --- a/auto-generated/api-testing/vlseg3e16.c +++ b/auto-generated/api-testing/vlseg3e16.c @@ -5,19 +5,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3(const float16_t *rs1, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3(const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf4x3(rs1, vl); } -vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3(const float16_t *rs1, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3(const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf2x3(rs1, vl); } -vfloat16m1x3_t test_vlseg3e16_v_f16m1x3(const float16_t *rs1, size_t vl) { +vfloat16m1x3_t test_vlseg3e16_v_f16m1x3(const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m1x3(rs1, vl); } -vfloat16m2x3_t test_vlseg3e16_v_f16m2x3(const float16_t *rs1, size_t vl) { +vfloat16m2x3_t test_vlseg3e16_v_f16m2x3(const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m2x3(rs1, vl); } @@ -53,22 +53,22 @@ vuint16m2x3_t test_vlseg3e16_v_u16m2x3(const uint16_t *rs1, size_t vl) { return __riscv_vlseg3e16_v_u16m2x3(rs1, vl); } -vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf4x3_m(vm, rs1, vl); } -vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf2x3_m(vm, rs1, vl); } -vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m1x3_m(vm, rs1, vl); } -vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m2x3_m(vm, rs1, vl); } diff --git a/auto-generated/api-testing/vlseg3e16ff.c b/auto-generated/api-testing/vlseg3e16ff.c index 4954008d7..6a4ccddbd 100644 --- a/auto-generated/api-testing/vlseg3e16ff.c +++ b/auto-generated/api-testing/vlseg3e16ff.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3(const float16_t *rs1, - size_t *new_vl, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3(const _Float16 *rs1, size_t *new_vl, + size_t vl) { return __riscv_vlseg3e16ff_v_f16mf4x3(rs1, new_vl, vl); } -vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3(const float16_t *rs1, - size_t *new_vl, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3(const _Float16 *rs1, size_t *new_vl, + size_t vl) { return __riscv_vlseg3e16ff_v_f16mf2x3(rs1, new_vl, vl); } -vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3(const float16_t *rs1, size_t *new_vl, +vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m1x3(rs1, new_vl, vl); } -vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3(const float16_t *rs1, size_t *new_vl, +vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m2x3(rs1, new_vl, vl); } @@ -65,24 +65,22 @@ vuint16m2x3_t test_vlseg3e16ff_v_u16m2x3(const uint16_t *rs1, size_t *new_vl, return __riscv_vlseg3e16ff_v_u16m2x3(rs1, new_vl, vl); } -vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf4x3_m(vm, rs1, new_vl, vl); } -vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf2x3_m(vm, rs1, new_vl, vl); } -vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m1x3_m(vm, rs1, new_vl, vl); } -vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m2x3_m(vm, rs1, new_vl, vl); } diff --git a/auto-generated/api-testing/vlseg4e16.c b/auto-generated/api-testing/vlseg4e16.c index d598f59f3..8d609f798 100644 --- a/auto-generated/api-testing/vlseg4e16.c +++ b/auto-generated/api-testing/vlseg4e16.c @@ -5,19 +5,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4(const float16_t *rs1, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4(const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf4x4(rs1, vl); } -vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4(const float16_t *rs1, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4(const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf2x4(rs1, vl); } -vfloat16m1x4_t test_vlseg4e16_v_f16m1x4(const float16_t *rs1, size_t vl) { +vfloat16m1x4_t test_vlseg4e16_v_f16m1x4(const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m1x4(rs1, vl); } -vfloat16m2x4_t test_vlseg4e16_v_f16m2x4(const float16_t *rs1, size_t vl) { +vfloat16m2x4_t test_vlseg4e16_v_f16m2x4(const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m2x4(rs1, vl); } @@ -53,22 +53,22 @@ vuint16m2x4_t test_vlseg4e16_v_u16m2x4(const uint16_t *rs1, size_t vl) { return __riscv_vlseg4e16_v_u16m2x4(rs1, vl); } -vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf4x4_m(vm, rs1, vl); } -vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf2x4_m(vm, rs1, vl); } -vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m1x4_m(vm, rs1, vl); } -vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m2x4_m(vm, rs1, vl); } diff --git a/auto-generated/api-testing/vlseg4e16ff.c b/auto-generated/api-testing/vlseg4e16ff.c index 8d7afa77a..843e61d4c 100644 --- a/auto-generated/api-testing/vlseg4e16ff.c +++ b/auto-generated/api-testing/vlseg4e16ff.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4(const float16_t *rs1, - size_t *new_vl, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4(const _Float16 *rs1, size_t *new_vl, + size_t vl) { return __riscv_vlseg4e16ff_v_f16mf4x4(rs1, new_vl, vl); } -vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4(const float16_t *rs1, - size_t *new_vl, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4(const _Float16 *rs1, size_t *new_vl, + size_t vl) { return __riscv_vlseg4e16ff_v_f16mf2x4(rs1, new_vl, vl); } -vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4(const float16_t *rs1, size_t *new_vl, +vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m1x4(rs1, new_vl, vl); } -vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4(const float16_t *rs1, size_t *new_vl, +vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m2x4(rs1, new_vl, vl); } @@ -65,24 +65,22 @@ vuint16m2x4_t test_vlseg4e16ff_v_u16m2x4(const uint16_t *rs1, size_t *new_vl, return __riscv_vlseg4e16ff_v_u16m2x4(rs1, new_vl, vl); } -vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf4x4_m(vm, rs1, new_vl, vl); } -vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf2x4_m(vm, rs1, new_vl, vl); } -vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m1x4_m(vm, rs1, new_vl, vl); } -vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m2x4_m(vm, rs1, new_vl, vl); } diff --git a/auto-generated/api-testing/vlseg5e16.c b/auto-generated/api-testing/vlseg5e16.c index 54d3f31e5..899eb19ba 100644 --- a/auto-generated/api-testing/vlseg5e16.c +++ b/auto-generated/api-testing/vlseg5e16.c @@ -5,15 +5,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5(const float16_t *rs1, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5(const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf4x5(rs1, vl); } -vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5(const float16_t *rs1, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5(const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf2x5(rs1, vl); } -vfloat16m1x5_t test_vlseg5e16_v_f16m1x5(const float16_t *rs1, size_t vl) { +vfloat16m1x5_t test_vlseg5e16_v_f16m1x5(const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16m1x5(rs1, vl); } @@ -41,17 +41,17 @@ vuint16m1x5_t test_vlseg5e16_v_u16m1x5(const uint16_t *rs1, size_t vl) { return __riscv_vlseg5e16_v_u16m1x5(rs1, vl); } -vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf4x5_m(vm, rs1, vl); } -vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf2x5_m(vm, rs1, vl); } -vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16m1x5_m(vm, rs1, vl); } diff --git a/auto-generated/api-testing/vlseg5e16ff.c b/auto-generated/api-testing/vlseg5e16ff.c index 1ea749b44..325e5350d 100644 --- a/auto-generated/api-testing/vlseg5e16ff.c +++ b/auto-generated/api-testing/vlseg5e16ff.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5(const float16_t *rs1, - size_t *new_vl, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5(const _Float16 *rs1, size_t *new_vl, + size_t vl) { return __riscv_vlseg5e16ff_v_f16mf4x5(rs1, new_vl, vl); } -vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5(const float16_t *rs1, - size_t *new_vl, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5(const _Float16 *rs1, size_t *new_vl, + size_t vl) { return __riscv_vlseg5e16ff_v_f16mf2x5(rs1, new_vl, vl); } -vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5(const float16_t *rs1, size_t *new_vl, +vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16m1x5(rs1, new_vl, vl); } @@ -50,19 +50,17 @@ vuint16m1x5_t test_vlseg5e16ff_v_u16m1x5(const uint16_t *rs1, size_t *new_vl, return __riscv_vlseg5e16ff_v_u16m1x5(rs1, new_vl, vl); } -vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf4x5_m(vm, rs1, new_vl, vl); } -vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf2x5_m(vm, rs1, new_vl, vl); } -vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16m1x5_m(vm, rs1, new_vl, vl); } diff --git a/auto-generated/api-testing/vlseg6e16.c b/auto-generated/api-testing/vlseg6e16.c index c1c5611d4..c906b06ab 100644 --- a/auto-generated/api-testing/vlseg6e16.c +++ b/auto-generated/api-testing/vlseg6e16.c @@ -5,15 +5,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6(const float16_t *rs1, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6(const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf4x6(rs1, vl); } -vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6(const float16_t *rs1, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6(const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf2x6(rs1, vl); } -vfloat16m1x6_t test_vlseg6e16_v_f16m1x6(const float16_t *rs1, size_t vl) { +vfloat16m1x6_t test_vlseg6e16_v_f16m1x6(const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16m1x6(rs1, vl); } @@ -41,17 +41,17 @@ vuint16m1x6_t test_vlseg6e16_v_u16m1x6(const uint16_t *rs1, size_t vl) { return __riscv_vlseg6e16_v_u16m1x6(rs1, vl); } -vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf4x6_m(vm, rs1, vl); } -vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf2x6_m(vm, rs1, vl); } -vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16m1x6_m(vm, rs1, vl); } diff --git a/auto-generated/api-testing/vlseg6e16ff.c b/auto-generated/api-testing/vlseg6e16ff.c index eff60cf32..15442efa5 100644 --- a/auto-generated/api-testing/vlseg6e16ff.c +++ b/auto-generated/api-testing/vlseg6e16ff.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6(const float16_t *rs1, - size_t *new_vl, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6(const _Float16 *rs1, size_t *new_vl, + size_t vl) { return __riscv_vlseg6e16ff_v_f16mf4x6(rs1, new_vl, vl); } -vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6(const float16_t *rs1, - size_t *new_vl, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6(const _Float16 *rs1, size_t *new_vl, + size_t vl) { return __riscv_vlseg6e16ff_v_f16mf2x6(rs1, new_vl, vl); } -vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6(const float16_t *rs1, size_t *new_vl, +vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16m1x6(rs1, new_vl, vl); } @@ -50,19 +50,17 @@ vuint16m1x6_t test_vlseg6e16ff_v_u16m1x6(const uint16_t *rs1, size_t *new_vl, return __riscv_vlseg6e16ff_v_u16m1x6(rs1, new_vl, vl); } -vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf4x6_m(vm, rs1, new_vl, vl); } -vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf2x6_m(vm, rs1, new_vl, vl); } -vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16m1x6_m(vm, rs1, new_vl, vl); } diff --git a/auto-generated/api-testing/vlseg7e16.c b/auto-generated/api-testing/vlseg7e16.c index 698d12518..7e2a05672 100644 --- a/auto-generated/api-testing/vlseg7e16.c +++ b/auto-generated/api-testing/vlseg7e16.c @@ -5,15 +5,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7(const float16_t *rs1, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7(const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf4x7(rs1, vl); } -vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7(const float16_t *rs1, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7(const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf2x7(rs1, vl); } -vfloat16m1x7_t test_vlseg7e16_v_f16m1x7(const float16_t *rs1, size_t vl) { +vfloat16m1x7_t test_vlseg7e16_v_f16m1x7(const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16m1x7(rs1, vl); } @@ -41,17 +41,17 @@ vuint16m1x7_t test_vlseg7e16_v_u16m1x7(const uint16_t *rs1, size_t vl) { return __riscv_vlseg7e16_v_u16m1x7(rs1, vl); } -vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf4x7_m(vm, rs1, vl); } -vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf2x7_m(vm, rs1, vl); } -vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16m1x7_m(vm, rs1, vl); } diff --git a/auto-generated/api-testing/vlseg7e16ff.c b/auto-generated/api-testing/vlseg7e16ff.c index 7485ed148..8ab9811d0 100644 --- a/auto-generated/api-testing/vlseg7e16ff.c +++ b/auto-generated/api-testing/vlseg7e16ff.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7(const float16_t *rs1, - size_t *new_vl, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7(const _Float16 *rs1, size_t *new_vl, + size_t vl) { return __riscv_vlseg7e16ff_v_f16mf4x7(rs1, new_vl, vl); } -vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7(const float16_t *rs1, - size_t *new_vl, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7(const _Float16 *rs1, size_t *new_vl, + size_t vl) { return __riscv_vlseg7e16ff_v_f16mf2x7(rs1, new_vl, vl); } -vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7(const float16_t *rs1, size_t *new_vl, +vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16m1x7(rs1, new_vl, vl); } @@ -50,19 +50,17 @@ vuint16m1x7_t test_vlseg7e16ff_v_u16m1x7(const uint16_t *rs1, size_t *new_vl, return __riscv_vlseg7e16ff_v_u16m1x7(rs1, new_vl, vl); } -vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf4x7_m(vm, rs1, new_vl, vl); } -vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf2x7_m(vm, rs1, new_vl, vl); } -vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16m1x7_m(vm, rs1, new_vl, vl); } diff --git a/auto-generated/api-testing/vlseg8e16.c b/auto-generated/api-testing/vlseg8e16.c index 3b5265816..c4d6a0dea 100644 --- a/auto-generated/api-testing/vlseg8e16.c +++ b/auto-generated/api-testing/vlseg8e16.c @@ -5,15 +5,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8(const float16_t *rs1, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8(const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf4x8(rs1, vl); } -vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8(const float16_t *rs1, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8(const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf2x8(rs1, vl); } -vfloat16m1x8_t test_vlseg8e16_v_f16m1x8(const float16_t *rs1, size_t vl) { +vfloat16m1x8_t test_vlseg8e16_v_f16m1x8(const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16m1x8(rs1, vl); } @@ -41,17 +41,17 @@ vuint16m1x8_t test_vlseg8e16_v_u16m1x8(const uint16_t *rs1, size_t vl) { return __riscv_vlseg8e16_v_u16m1x8(rs1, vl); } -vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf4x8_m(vm, rs1, vl); } -vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf2x8_m(vm, rs1, vl); } -vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16m1x8_m(vm, rs1, vl); } diff --git a/auto-generated/api-testing/vlseg8e16ff.c b/auto-generated/api-testing/vlseg8e16ff.c index 3aedb684f..f7b386e0b 100644 --- a/auto-generated/api-testing/vlseg8e16ff.c +++ b/auto-generated/api-testing/vlseg8e16ff.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8(const float16_t *rs1, - size_t *new_vl, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8(const _Float16 *rs1, size_t *new_vl, + size_t vl) { return __riscv_vlseg8e16ff_v_f16mf4x8(rs1, new_vl, vl); } -vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8(const float16_t *rs1, - size_t *new_vl, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8(const _Float16 *rs1, size_t *new_vl, + size_t vl) { return __riscv_vlseg8e16ff_v_f16mf2x8(rs1, new_vl, vl); } -vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8(const float16_t *rs1, size_t *new_vl, +vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16m1x8(rs1, new_vl, vl); } @@ -50,19 +50,17 @@ vuint16m1x8_t test_vlseg8e16ff_v_u16m1x8(const uint16_t *rs1, size_t *new_vl, return __riscv_vlseg8e16ff_v_u16m1x8(rs1, new_vl, vl); } -vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf4x8_m(vm, rs1, new_vl, vl); } -vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf2x8_m(vm, rs1, new_vl, vl); } -vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16m1x8_m(vm, rs1, new_vl, vl); } diff --git a/auto-generated/api-testing/vlsseg2e16.c b/auto-generated/api-testing/vlsseg2e16.c index d3c1be233..882669919 100644 --- a/auto-generated/api-testing/vlsseg2e16.c +++ b/auto-generated/api-testing/vlsseg2e16.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2(const float16_t *rs1, ptrdiff_t rs2, +vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2(const float16_t *rs1, ptrdiff_t rs2, +vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2(const float16_t *rs1, ptrdiff_t rs2, +vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2(const float16_t *rs1, ptrdiff_t rs2, +vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m2x2(rs1, rs2, vl); } -vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2(const float16_t *rs1, ptrdiff_t rs2, +vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m4x2(rs1, rs2, vl); } @@ -80,27 +80,27 @@ vuint16m4x2_t test_vlsseg2e16_v_u16m4x2(const uint16_t *rs1, ptrdiff_t rs2, return __riscv_vlsseg2e16_v_u16m4x2(rs1, rs2, vl); } -vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf4x2_m(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m2x2_m(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m4x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vlsseg3e16.c b/auto-generated/api-testing/vlsseg3e16.c index 907df8d55..58bf21e1c 100644 --- a/auto-generated/api-testing/vlsseg3e16.c +++ b/auto-generated/api-testing/vlsseg3e16.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3(const float16_t *rs1, ptrdiff_t rs2, +vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3(const float16_t *rs1, ptrdiff_t rs2, +vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3(const float16_t *rs1, ptrdiff_t rs2, +vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3(const float16_t *rs1, ptrdiff_t rs2, +vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m2x3(rs1, rs2, vl); } @@ -65,22 +65,22 @@ vuint16m2x3_t test_vlsseg3e16_v_u16m2x3(const uint16_t *rs1, ptrdiff_t rs2, return __riscv_vlsseg3e16_v_u16m2x3(rs1, rs2, vl); } -vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf4x3_m(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vlsseg4e16.c b/auto-generated/api-testing/vlsseg4e16.c index b272af400..33822d689 100644 --- a/auto-generated/api-testing/vlsseg4e16.c +++ b/auto-generated/api-testing/vlsseg4e16.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4(const float16_t *rs1, ptrdiff_t rs2, +vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4(const float16_t *rs1, ptrdiff_t rs2, +vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4(const float16_t *rs1, ptrdiff_t rs2, +vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4(const float16_t *rs1, ptrdiff_t rs2, +vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m2x4(rs1, rs2, vl); } @@ -65,22 +65,22 @@ vuint16m2x4_t test_vlsseg4e16_v_u16m2x4(const uint16_t *rs1, ptrdiff_t rs2, return __riscv_vlsseg4e16_v_u16m2x4(rs1, rs2, vl); } -vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf4x4_m(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vlsseg5e16.c b/auto-generated/api-testing/vlsseg5e16.c index 0c50ac525..960a06fd5 100644 --- a/auto-generated/api-testing/vlsseg5e16.c +++ b/auto-generated/api-testing/vlsseg5e16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5(const float16_t *rs1, ptrdiff_t rs2, +vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5(const float16_t *rs1, ptrdiff_t rs2, +vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5(const float16_t *rs1, ptrdiff_t rs2, +vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16m1x5(rs1, rs2, vl); } @@ -50,17 +50,17 @@ vuint16m1x5_t test_vlsseg5e16_v_u16m1x5(const uint16_t *rs1, ptrdiff_t rs2, return __riscv_vlsseg5e16_v_u16m1x5(rs1, rs2, vl); } -vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf4x5_m(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vlsseg6e16.c b/auto-generated/api-testing/vlsseg6e16.c index c25699705..5eb83ee1a 100644 --- a/auto-generated/api-testing/vlsseg6e16.c +++ b/auto-generated/api-testing/vlsseg6e16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6(const float16_t *rs1, ptrdiff_t rs2, +vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6(const float16_t *rs1, ptrdiff_t rs2, +vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6(const float16_t *rs1, ptrdiff_t rs2, +vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16m1x6(rs1, rs2, vl); } @@ -50,17 +50,17 @@ vuint16m1x6_t test_vlsseg6e16_v_u16m1x6(const uint16_t *rs1, ptrdiff_t rs2, return __riscv_vlsseg6e16_v_u16m1x6(rs1, rs2, vl); } -vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf4x6_m(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vlsseg7e16.c b/auto-generated/api-testing/vlsseg7e16.c index 321e50435..eaa770972 100644 --- a/auto-generated/api-testing/vlsseg7e16.c +++ b/auto-generated/api-testing/vlsseg7e16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7(const float16_t *rs1, ptrdiff_t rs2, +vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7(const float16_t *rs1, ptrdiff_t rs2, +vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7(const float16_t *rs1, ptrdiff_t rs2, +vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16m1x7(rs1, rs2, vl); } @@ -50,17 +50,17 @@ vuint16m1x7_t test_vlsseg7e16_v_u16m1x7(const uint16_t *rs1, ptrdiff_t rs2, return __riscv_vlsseg7e16_v_u16m1x7(rs1, rs2, vl); } -vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf4x7_m(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vlsseg8e16.c b/auto-generated/api-testing/vlsseg8e16.c index 7d43e0bd5..a4e622b7c 100644 --- a/auto-generated/api-testing/vlsseg8e16.c +++ b/auto-generated/api-testing/vlsseg8e16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8(const float16_t *rs1, ptrdiff_t rs2, +vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8(const float16_t *rs1, ptrdiff_t rs2, +vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8(const float16_t *rs1, ptrdiff_t rs2, +vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16m1x8(rs1, rs2, vl); } @@ -50,17 +50,17 @@ vuint16m1x8_t test_vlsseg8e16_v_u16m1x8(const uint16_t *rs1, ptrdiff_t rs2, return __riscv_vlsseg8e16_v_u16m1x8(rs1, rs2, vl); } -vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf4x8_m(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxei16.c b/auto-generated/api-testing/vluxei16.c index f1a56b87d..e7890fa36 100644 --- a/auto-generated/api-testing/vluxei16.c +++ b/auto-generated/api-testing/vluxei16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei16_v_f16mf4(const float16_t *rs1, vuint16mf4_t rs2, +vfloat16mf4_t test_vluxei16_v_f16mf4(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2(const float16_t *rs1, vuint16mf2_t rs2, +vfloat16mf2_t test_vluxei16_v_f16mf2(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1(const float16_t *rs1, vuint16m1_t rs2, +vfloat16m1_t test_vluxei16_v_f16m1(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2(const float16_t *rs1, vuint16m2_t rs2, +vfloat16m2_t test_vluxei16_v_f16m2(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m2(rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4(const float16_t *rs1, vuint16m4_t rs2, +vfloat16m4_t test_vluxei16_v_f16m4(const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m4(rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8(const float16_t *rs1, vuint16m8_t rs2, +vfloat16m8_t test_vluxei16_v_f16m8(const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m8(rs1, rs2, vl); } @@ -287,32 +287,32 @@ vuint64m8_t test_vluxei16_v_u64m8(const uint64_t *rs1, vuint16m2_t rs2, return __riscv_vluxei16_v_u64m8(rs1, rs2, vl); } -vfloat16mf4_t test_vluxei16_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vluxei16_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vluxei16_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vluxei16_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vluxei16_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m2_m(vm, rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4_t test_vluxei16_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m4_m(vm, rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8_m(vbool2_t vm, const float16_t *rs1, +vfloat16m8_t test_vluxei16_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxei32.c b/auto-generated/api-testing/vluxei32.c index 3c128823d..b92fd73e0 100644 --- a/auto-generated/api-testing/vluxei32.c +++ b/auto-generated/api-testing/vluxei32.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei32_v_f16mf4(const float16_t *rs1, vuint32mf2_t rs2, +vfloat16mf4_t test_vluxei32_v_f16mf4(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2(const float16_t *rs1, vuint32m1_t rs2, +vfloat16mf2_t test_vluxei32_v_f16mf2(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1(const float16_t *rs1, vuint32m2_t rs2, +vfloat16m1_t test_vluxei32_v_f16m1(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2(const float16_t *rs1, vuint32m4_t rs2, +vfloat16m2_t test_vluxei32_v_f16m2(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m2(rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4(const float16_t *rs1, vuint32m8_t rs2, +vfloat16m4_t test_vluxei32_v_f16m4(const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m4(rs1, rs2, vl); } @@ -263,27 +263,27 @@ vuint64m8_t test_vluxei32_v_u64m8(const uint64_t *rs1, vuint32m4_t rs2, return __riscv_vluxei32_v_u64m8(rs1, rs2, vl); } -vfloat16mf4_t test_vluxei32_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vluxei32_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vluxei32_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vluxei32_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vluxei32_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m2_m(vm, rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4_t test_vluxei32_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxei64.c b/auto-generated/api-testing/vluxei64.c index 0b6b518f2..b595f6cbf 100644 --- a/auto-generated/api-testing/vluxei64.c +++ b/auto-generated/api-testing/vluxei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei64_v_f16mf4(const float16_t *rs1, vuint64m1_t rs2, +vfloat16mf4_t test_vluxei64_v_f16mf4(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2(const float16_t *rs1, vuint64m2_t rs2, +vfloat16mf2_t test_vluxei64_v_f16mf2(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1(const float16_t *rs1, vuint64m4_t rs2, +vfloat16m1_t test_vluxei64_v_f16m1(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2(const float16_t *rs1, vuint64m8_t rs2, +vfloat16m2_t test_vluxei64_v_f16m2(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m2(rs1, rs2, vl); } @@ -224,22 +224,22 @@ vuint64m8_t test_vluxei64_v_u64m8(const uint64_t *rs1, vuint64m8_t rs2, return __riscv_vluxei64_v_u64m8(rs1, rs2, vl); } -vfloat16mf4_t test_vluxei64_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vluxei64_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vluxei64_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vluxei64_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vluxei64_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxei8.c b/auto-generated/api-testing/vluxei8.c index a8fa1d9ef..7c42241a2 100644 --- a/auto-generated/api-testing/vluxei8.c +++ b/auto-generated/api-testing/vluxei8.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei8_v_f16mf4(const float16_t *rs1, vuint8mf8_t rs2, +vfloat16mf4_t test_vluxei8_v_f16mf4(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2(const float16_t *rs1, vuint8mf4_t rs2, +vfloat16mf2_t test_vluxei8_v_f16mf2(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1_t test_vluxei8_v_f16m1(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2(const float16_t *rs1, vuint8m1_t rs2, +vfloat16m2_t test_vluxei8_v_f16m2(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m2(rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4(const float16_t *rs1, vuint8m2_t rs2, +vfloat16m4_t test_vluxei8_v_f16m4(const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m4(rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8(const float16_t *rs1, vuint8m4_t rs2, +vfloat16m8_t test_vluxei8_v_f16m8(const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m8(rs1, rs2, vl); } @@ -283,32 +283,32 @@ vuint64m8_t test_vluxei8_v_u64m8(const uint64_t *rs1, vuint8m1_t rs2, return __riscv_vluxei8_v_u64m8(rs1, rs2, vl); } -vfloat16mf4_t test_vluxei8_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vluxei8_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vluxei8_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vluxei8_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vluxei8_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m2_m(vm, rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4_t test_vluxei8_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m4_m(vm, rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8_m(vbool2_t vm, const float16_t *rs1, +vfloat16m8_t test_vluxei8_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg2ei16.c b/auto-generated/api-testing/vluxseg2ei16.c index 166f9d379..2004257ec 100644 --- a/auto-generated/api-testing/vluxseg2ei16.c +++ b/auto-generated/api-testing/vluxseg2ei16.c @@ -5,28 +5,28 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2(const float16_t *rs1, +vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2(const float16_t *rs1, +vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vluxseg2ei16_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2(const float16_t *rs1, - vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2(const _Float16 *rs1, vuint16m2_t rs2, + size_t vl) { return __riscv_vluxseg2ei16_v_f16m2x2(rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2(const float16_t *rs1, - vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2(const _Float16 *rs1, vuint16m4_t rs2, + size_t vl) { return __riscv_vluxseg2ei16_v_f16m4x2(rs1, rs2, vl); } @@ -246,28 +246,28 @@ vuint64m4x2_t test_vluxseg2ei16_v_u64m4x2(const uint64_t *rs1, vuint16m1_t rs2, } vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf4x2_m(vm, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m2x2_m(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m4x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg2ei32.c b/auto-generated/api-testing/vluxseg2ei32.c index b5ddc4152..4871f67af 100644 --- a/auto-generated/api-testing/vluxseg2ei32.c +++ b/auto-generated/api-testing/vluxseg2ei32.c @@ -5,28 +5,28 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2(const float16_t *rs1, +vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2(const float16_t *rs1, +vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vluxseg2ei32_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2(const float16_t *rs1, - vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2(const _Float16 *rs1, vuint32m4_t rs2, + size_t vl) { return __riscv_vluxseg2ei32_v_f16m2x2(rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2(const float16_t *rs1, - vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2(const _Float16 *rs1, vuint32m8_t rs2, + size_t vl) { return __riscv_vluxseg2ei32_v_f16m4x2(rs1, rs2, vl); } @@ -236,28 +236,28 @@ vuint64m4x2_t test_vluxseg2ei32_v_u64m4x2(const uint64_t *rs1, vuint32m2_t rs2, } vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf4x2_m(vm, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m2x2_m(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m4x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg2ei64.c b/auto-generated/api-testing/vluxseg2ei64.c index a51472ff7..514654c32 100644 --- a/auto-generated/api-testing/vluxseg2ei64.c +++ b/auto-generated/api-testing/vluxseg2ei64.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2(const float16_t *rs1, +vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2(const float16_t *rs1, +vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vluxseg2ei64_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2(const float16_t *rs1, - vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2(const _Float16 *rs1, vuint64m8_t rs2, + size_t vl) { return __riscv_vluxseg2ei64_v_f16m2x2(rs1, rs2, vl); } @@ -211,23 +211,23 @@ vuint64m4x2_t test_vluxseg2ei64_v_u64m4x2(const uint64_t *rs1, vuint64m4_t rs2, } vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf4x2_m(vm, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m2x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg2ei8.c b/auto-generated/api-testing/vluxseg2ei8.c index 46f963516..a5bc43f52 100644 --- a/auto-generated/api-testing/vluxseg2ei8.c +++ b/auto-generated/api-testing/vluxseg2ei8.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2(const float16_t *rs1, +vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2(const float16_t *rs1, +vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2(const float16_t *rs1, vuint8m1_t rs2, +vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m2x2(rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2(const float16_t *rs1, vuint8m2_t rs2, +vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2(const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m4x2(rs1, rs2, vl); } @@ -245,29 +245,27 @@ vuint64m4x2_t test_vluxseg2ei8_v_u64m4x2(const uint64_t *rs1, vuint8mf2_t rs2, return __riscv_vluxseg2ei8_v_u64m4x2(rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf4x2_m(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m2x2_m(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m4x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg3ei16.c b/auto-generated/api-testing/vluxseg3ei16.c index e0129f19c..a2c70ebf2 100644 --- a/auto-generated/api-testing/vluxseg3ei16.c +++ b/auto-generated/api-testing/vluxseg3ei16.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3(const float16_t *rs1, +vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3(const float16_t *rs1, +vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vluxseg3ei16_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3(const float16_t *rs1, - vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3(const _Float16 *rs1, vuint16m2_t rs2, + size_t vl) { return __riscv_vluxseg3ei16_v_f16m2x3(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m2x3_t test_vluxseg3ei16_v_u64m2x3(const uint64_t *rs1, vuint16mf2_t rs2, } vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf4x3_m(vm, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg3ei32.c b/auto-generated/api-testing/vluxseg3ei32.c index caf643a4a..78b890e9a 100644 --- a/auto-generated/api-testing/vluxseg3ei32.c +++ b/auto-generated/api-testing/vluxseg3ei32.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3(const float16_t *rs1, +vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3(const float16_t *rs1, +vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vluxseg3ei32_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3(const float16_t *rs1, - vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3(const _Float16 *rs1, vuint32m4_t rs2, + size_t vl) { return __riscv_vluxseg3ei32_v_f16m2x3(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m2x3_t test_vluxseg3ei32_v_u64m2x3(const uint64_t *rs1, vuint32m1_t rs2, } vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf4x3_m(vm, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg3ei64.c b/auto-generated/api-testing/vluxseg3ei64.c index 8afd5ffce..bf3b8b506 100644 --- a/auto-generated/api-testing/vluxseg3ei64.c +++ b/auto-generated/api-testing/vluxseg3ei64.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3(const float16_t *rs1, +vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3(const float16_t *rs1, +vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vluxseg3ei64_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3(const float16_t *rs1, - vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3(const _Float16 *rs1, vuint64m8_t rs2, + size_t vl) { return __riscv_vluxseg3ei64_v_f16m2x3(rs1, rs2, vl); } @@ -181,23 +181,23 @@ vuint64m2x3_t test_vluxseg3ei64_v_u64m2x3(const uint64_t *rs1, vuint64m2_t rs2, } vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf4x3_m(vm, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg3ei8.c b/auto-generated/api-testing/vluxseg3ei8.c index eb40d3952..354aacbd8 100644 --- a/auto-generated/api-testing/vluxseg3ei8.c +++ b/auto-generated/api-testing/vluxseg3ei8.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3(const float16_t *rs1, +vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3(const float16_t *rs1, +vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3(const float16_t *rs1, vuint8m1_t rs2, +vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m2x3(rs1, rs2, vl); } @@ -190,24 +190,22 @@ vuint64m2x3_t test_vluxseg3ei8_v_u64m2x3(const uint64_t *rs1, vuint8mf4_t rs2, return __riscv_vluxseg3ei8_v_u64m2x3(rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf4x3_m(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg4ei16.c b/auto-generated/api-testing/vluxseg4ei16.c index 2dd6f24c8..32abc2bd5 100644 --- a/auto-generated/api-testing/vluxseg4ei16.c +++ b/auto-generated/api-testing/vluxseg4ei16.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4(const float16_t *rs1, +vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4(const float16_t *rs1, +vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vluxseg4ei16_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4(const float16_t *rs1, - vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4(const _Float16 *rs1, vuint16m2_t rs2, + size_t vl) { return __riscv_vluxseg4ei16_v_f16m2x4(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m2x4_t test_vluxseg4ei16_v_u64m2x4(const uint64_t *rs1, vuint16mf2_t rs2, } vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf4x4_m(vm, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg4ei32.c b/auto-generated/api-testing/vluxseg4ei32.c index d0e663cd0..536b58489 100644 --- a/auto-generated/api-testing/vluxseg4ei32.c +++ b/auto-generated/api-testing/vluxseg4ei32.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4(const float16_t *rs1, +vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4(const float16_t *rs1, +vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vluxseg4ei32_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4(const float16_t *rs1, - vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4(const _Float16 *rs1, vuint32m4_t rs2, + size_t vl) { return __riscv_vluxseg4ei32_v_f16m2x4(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m2x4_t test_vluxseg4ei32_v_u64m2x4(const uint64_t *rs1, vuint32m1_t rs2, } vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf4x4_m(vm, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg4ei64.c b/auto-generated/api-testing/vluxseg4ei64.c index 72b1a07b4..cdd5da8c7 100644 --- a/auto-generated/api-testing/vluxseg4ei64.c +++ b/auto-generated/api-testing/vluxseg4ei64.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4(const float16_t *rs1, +vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4(const float16_t *rs1, +vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vluxseg4ei64_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4(const float16_t *rs1, - vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4(const _Float16 *rs1, vuint64m8_t rs2, + size_t vl) { return __riscv_vluxseg4ei64_v_f16m2x4(rs1, rs2, vl); } @@ -181,23 +181,23 @@ vuint64m2x4_t test_vluxseg4ei64_v_u64m2x4(const uint64_t *rs1, vuint64m2_t rs2, } vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf4x4_m(vm, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg4ei8.c b/auto-generated/api-testing/vluxseg4ei8.c index 4d6876322..b9123a72c 100644 --- a/auto-generated/api-testing/vluxseg4ei8.c +++ b/auto-generated/api-testing/vluxseg4ei8.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4(const float16_t *rs1, +vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4(const float16_t *rs1, +vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4(const float16_t *rs1, vuint8m1_t rs2, +vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m2x4(rs1, rs2, vl); } @@ -190,24 +190,22 @@ vuint64m2x4_t test_vluxseg4ei8_v_u64m2x4(const uint64_t *rs1, vuint8mf4_t rs2, return __riscv_vluxseg4ei8_v_u64m2x4(rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf4x4_m(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg5ei16.c b/auto-generated/api-testing/vluxseg5ei16.c index c544a0c9a..41b0c6694 100644 --- a/auto-generated/api-testing/vluxseg5ei16.c +++ b/auto-generated/api-testing/vluxseg5ei16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5(const float16_t *rs1, +vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5(const float16_t *rs1, +vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vluxseg5ei16_v_f16m1x5(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x5_t test_vluxseg5ei16_v_u64m1x5(const uint64_t *rs1, vuint16mf4_t rs2, } vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf4x5_m(vm, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg5ei32.c b/auto-generated/api-testing/vluxseg5ei32.c index f99a390ad..34e23b189 100644 --- a/auto-generated/api-testing/vluxseg5ei32.c +++ b/auto-generated/api-testing/vluxseg5ei32.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5(const float16_t *rs1, +vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5(const float16_t *rs1, +vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vluxseg5ei32_v_f16m1x5(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x5_t test_vluxseg5ei32_v_u64m1x5(const uint64_t *rs1, vuint32mf2_t rs2, } vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf4x5_m(vm, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg5ei64.c b/auto-generated/api-testing/vluxseg5ei64.c index cf83cf08a..f4968edef 100644 --- a/auto-generated/api-testing/vluxseg5ei64.c +++ b/auto-generated/api-testing/vluxseg5ei64.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5(const float16_t *rs1, +vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5(const float16_t *rs1, +vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vluxseg5ei64_v_f16m1x5(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x5_t test_vluxseg5ei64_v_u64m1x5(const uint64_t *rs1, vuint64m1_t rs2, } vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf4x5_m(vm, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg5ei8.c b/auto-generated/api-testing/vluxseg5ei8.c index 1d9e22725..6747236d6 100644 --- a/auto-generated/api-testing/vluxseg5ei8.c +++ b/auto-generated/api-testing/vluxseg5ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5(const float16_t *rs1, +vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5(const float16_t *rs1, +vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16m1x5(rs1, rs2, vl); } @@ -135,19 +135,17 @@ vuint64m1x5_t test_vluxseg5ei8_v_u64m1x5(const uint64_t *rs1, vuint8mf8_t rs2, return __riscv_vluxseg5ei8_v_u64m1x5(rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf4x5_m(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg6ei16.c b/auto-generated/api-testing/vluxseg6ei16.c index 43786aa2f..57025018c 100644 --- a/auto-generated/api-testing/vluxseg6ei16.c +++ b/auto-generated/api-testing/vluxseg6ei16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6(const float16_t *rs1, +vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6(const float16_t *rs1, +vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vluxseg6ei16_v_f16m1x6(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x6_t test_vluxseg6ei16_v_u64m1x6(const uint64_t *rs1, vuint16mf4_t rs2, } vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf4x6_m(vm, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg6ei32.c b/auto-generated/api-testing/vluxseg6ei32.c index 0e19ba45c..1f58a6008 100644 --- a/auto-generated/api-testing/vluxseg6ei32.c +++ b/auto-generated/api-testing/vluxseg6ei32.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6(const float16_t *rs1, +vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6(const float16_t *rs1, +vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vluxseg6ei32_v_f16m1x6(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x6_t test_vluxseg6ei32_v_u64m1x6(const uint64_t *rs1, vuint32mf2_t rs2, } vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf4x6_m(vm, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg6ei64.c b/auto-generated/api-testing/vluxseg6ei64.c index b133b3dad..c1a1c1a7e 100644 --- a/auto-generated/api-testing/vluxseg6ei64.c +++ b/auto-generated/api-testing/vluxseg6ei64.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6(const float16_t *rs1, +vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6(const float16_t *rs1, +vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vluxseg6ei64_v_f16m1x6(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x6_t test_vluxseg6ei64_v_u64m1x6(const uint64_t *rs1, vuint64m1_t rs2, } vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf4x6_m(vm, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg6ei8.c b/auto-generated/api-testing/vluxseg6ei8.c index 4dcb61099..91f16e0d3 100644 --- a/auto-generated/api-testing/vluxseg6ei8.c +++ b/auto-generated/api-testing/vluxseg6ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6(const float16_t *rs1, +vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6(const float16_t *rs1, +vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16m1x6(rs1, rs2, vl); } @@ -135,19 +135,17 @@ vuint64m1x6_t test_vluxseg6ei8_v_u64m1x6(const uint64_t *rs1, vuint8mf8_t rs2, return __riscv_vluxseg6ei8_v_u64m1x6(rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf4x6_m(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg7ei16.c b/auto-generated/api-testing/vluxseg7ei16.c index acf9073c9..38e3bf6ca 100644 --- a/auto-generated/api-testing/vluxseg7ei16.c +++ b/auto-generated/api-testing/vluxseg7ei16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7(const float16_t *rs1, +vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7(const float16_t *rs1, +vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vluxseg7ei16_v_f16m1x7(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x7_t test_vluxseg7ei16_v_u64m1x7(const uint64_t *rs1, vuint16mf4_t rs2, } vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf4x7_m(vm, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg7ei32.c b/auto-generated/api-testing/vluxseg7ei32.c index 3a83dfc94..f3856245c 100644 --- a/auto-generated/api-testing/vluxseg7ei32.c +++ b/auto-generated/api-testing/vluxseg7ei32.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7(const float16_t *rs1, +vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7(const float16_t *rs1, +vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vluxseg7ei32_v_f16m1x7(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x7_t test_vluxseg7ei32_v_u64m1x7(const uint64_t *rs1, vuint32mf2_t rs2, } vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf4x7_m(vm, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg7ei64.c b/auto-generated/api-testing/vluxseg7ei64.c index 1a70481e0..8c4a71c12 100644 --- a/auto-generated/api-testing/vluxseg7ei64.c +++ b/auto-generated/api-testing/vluxseg7ei64.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7(const float16_t *rs1, +vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7(const float16_t *rs1, +vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vluxseg7ei64_v_f16m1x7(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x7_t test_vluxseg7ei64_v_u64m1x7(const uint64_t *rs1, vuint64m1_t rs2, } vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf4x7_m(vm, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg7ei8.c b/auto-generated/api-testing/vluxseg7ei8.c index ae2b0d561..712cd90a2 100644 --- a/auto-generated/api-testing/vluxseg7ei8.c +++ b/auto-generated/api-testing/vluxseg7ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7(const float16_t *rs1, +vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7(const float16_t *rs1, +vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16m1x7(rs1, rs2, vl); } @@ -135,19 +135,17 @@ vuint64m1x7_t test_vluxseg7ei8_v_u64m1x7(const uint64_t *rs1, vuint8mf8_t rs2, return __riscv_vluxseg7ei8_v_u64m1x7(rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf4x7_m(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg8ei16.c b/auto-generated/api-testing/vluxseg8ei16.c index d933cdbe9..ba5328156 100644 --- a/auto-generated/api-testing/vluxseg8ei16.c +++ b/auto-generated/api-testing/vluxseg8ei16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8(const float16_t *rs1, +vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8(const float16_t *rs1, +vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vluxseg8ei16_v_f16m1x8(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x8_t test_vluxseg8ei16_v_u64m1x8(const uint64_t *rs1, vuint16mf4_t rs2, } vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf4x8_m(vm, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg8ei32.c b/auto-generated/api-testing/vluxseg8ei32.c index bd1778c02..81b4e9cff 100644 --- a/auto-generated/api-testing/vluxseg8ei32.c +++ b/auto-generated/api-testing/vluxseg8ei32.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8(const float16_t *rs1, +vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8(const float16_t *rs1, +vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vluxseg8ei32_v_f16m1x8(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x8_t test_vluxseg8ei32_v_u64m1x8(const uint64_t *rs1, vuint32mf2_t rs2, } vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf4x8_m(vm, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg8ei64.c b/auto-generated/api-testing/vluxseg8ei64.c index e35f8640b..322ebf24e 100644 --- a/auto-generated/api-testing/vluxseg8ei64.c +++ b/auto-generated/api-testing/vluxseg8ei64.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8(const float16_t *rs1, +vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8(const float16_t *rs1, +vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vluxseg8ei64_v_f16m1x8(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x8_t test_vluxseg8ei64_v_u64m1x8(const uint64_t *rs1, vuint64m1_t rs2, } vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf4x8_m(vm, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vluxseg8ei8.c b/auto-generated/api-testing/vluxseg8ei8.c index e57a4458d..756d1ec82 100644 --- a/auto-generated/api-testing/vluxseg8ei8.c +++ b/auto-generated/api-testing/vluxseg8ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8(const float16_t *rs1, +vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8(const float16_t *rs1, +vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16m1x8(rs1, rs2, vl); } @@ -135,19 +135,17 @@ vuint64m1x8_t test_vluxseg8ei8_v_u64m1x8(const uint64_t *rs1, vuint8mf8_t rs2, return __riscv_vluxseg8ei8_v_u64m1x8(rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf4x8_m(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/api-testing/vse16.c b/auto-generated/api-testing/vse16.c index 298e3aa1c..1b3304e0f 100644 --- a/auto-generated/api-testing/vse16.c +++ b/auto-generated/api-testing/vse16.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vse16_v_f16mf4(float16_t *rs1, vfloat16mf4_t vs3, size_t vl) { +void test_vse16_v_f16mf4(_Float16 *rs1, vfloat16mf4_t vs3, size_t vl) { return __riscv_vse16_v_f16mf4(rs1, vs3, vl); } -void test_vse16_v_f16mf2(float16_t *rs1, vfloat16mf2_t vs3, size_t vl) { +void test_vse16_v_f16mf2(_Float16 *rs1, vfloat16mf2_t vs3, size_t vl) { return __riscv_vse16_v_f16mf2(rs1, vs3, vl); } -void test_vse16_v_f16m1(float16_t *rs1, vfloat16m1_t vs3, size_t vl) { +void test_vse16_v_f16m1(_Float16 *rs1, vfloat16m1_t vs3, size_t vl) { return __riscv_vse16_v_f16m1(rs1, vs3, vl); } -void test_vse16_v_f16m2(float16_t *rs1, vfloat16m2_t vs3, size_t vl) { +void test_vse16_v_f16m2(_Float16 *rs1, vfloat16m2_t vs3, size_t vl) { return __riscv_vse16_v_f16m2(rs1, vs3, vl); } -void test_vse16_v_f16m4(float16_t *rs1, vfloat16m4_t vs3, size_t vl) { +void test_vse16_v_f16m4(_Float16 *rs1, vfloat16m4_t vs3, size_t vl) { return __riscv_vse16_v_f16m4(rs1, vs3, vl); } -void test_vse16_v_f16m8(float16_t *rs1, vfloat16m8_t vs3, size_t vl) { +void test_vse16_v_f16m8(_Float16 *rs1, vfloat16m8_t vs3, size_t vl) { return __riscv_vse16_v_f16m8(rs1, vs3, vl); } @@ -77,32 +77,32 @@ void test_vse16_v_u16m8(uint16_t *rs1, vuint16m8_t vs3, size_t vl) { return __riscv_vse16_v_u16m8(rs1, vs3, vl); } -void test_vse16_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vfloat16mf4_t vs3, +void test_vse16_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4_t vs3, size_t vl) { return __riscv_vse16_v_f16mf4_m(vm, rs1, vs3, vl); } -void test_vse16_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vfloat16mf2_t vs3, +void test_vse16_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2_t vs3, size_t vl) { return __riscv_vse16_v_f16mf2_m(vm, rs1, vs3, vl); } -void test_vse16_v_f16m1_m(vbool16_t vm, float16_t *rs1, vfloat16m1_t vs3, +void test_vse16_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vfloat16m1_t vs3, size_t vl) { return __riscv_vse16_v_f16m1_m(vm, rs1, vs3, vl); } -void test_vse16_v_f16m2_m(vbool8_t vm, float16_t *rs1, vfloat16m2_t vs3, +void test_vse16_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vfloat16m2_t vs3, size_t vl) { return __riscv_vse16_v_f16m2_m(vm, rs1, vs3, vl); } -void test_vse16_v_f16m4_m(vbool4_t vm, float16_t *rs1, vfloat16m4_t vs3, +void test_vse16_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vfloat16m4_t vs3, size_t vl) { return __riscv_vse16_v_f16m4_m(vm, rs1, vs3, vl); } -void test_vse16_v_f16m8_m(vbool2_t vm, float16_t *rs1, vfloat16m8_t vs3, +void test_vse16_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vfloat16m8_t vs3, size_t vl) { return __riscv_vse16_v_f16m8_m(vm, rs1, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxei16.c b/auto-generated/api-testing/vsoxei16.c index bcb095450..e69959d2d 100644 --- a/auto-generated/api-testing/vsoxei16.c +++ b/auto-generated/api-testing/vsoxei16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxei16_v_f16mf4(float16_t *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, +void test_vsoxei16_v_f16mf4(_Float16 *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16mf2(float16_t *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, +void test_vsoxei16_v_f16mf2(_Float16 *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m1(float16_t *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, +void test_vsoxei16_v_f16m1(_Float16 *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m2(float16_t *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, +void test_vsoxei16_v_f16m2(_Float16 *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16m2(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m4(float16_t *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, +void test_vsoxei16_v_f16m4(_Float16 *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16m4(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m8(float16_t *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, +void test_vsoxei16_v_f16m8(_Float16 *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16m8(rs1, rs2, vs3, vl); } @@ -290,32 +290,32 @@ void test_vsoxei16_v_u64m8(uint64_t *rs1, vuint16m2_t rs2, vuint64m8_t vs3, return __riscv_vsoxei16_v_u64m8(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t rs2, +void test_vsoxei16_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t rs2, +void test_vsoxei16_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint16m1_t rs2, +void test_vsoxei16_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint16m2_t rs2, +void test_vsoxei16_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16m2_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint16m4_t rs2, +void test_vsoxei16_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16m4_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m8_m(vbool2_t vm, float16_t *rs1, vuint16m8_t rs2, +void test_vsoxei16_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16m8_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxei32.c b/auto-generated/api-testing/vsoxei32.c index f7b9def07..02edd0fba 100644 --- a/auto-generated/api-testing/vsoxei32.c +++ b/auto-generated/api-testing/vsoxei32.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxei32_v_f16mf4(float16_t *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, +void test_vsoxei32_v_f16mf4(_Float16 *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16mf2(float16_t *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, +void test_vsoxei32_v_f16mf2(_Float16 *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m1(float16_t *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, +void test_vsoxei32_v_f16m1(_Float16 *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m2(float16_t *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, +void test_vsoxei32_v_f16m2(_Float16 *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16m2(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m4(float16_t *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, +void test_vsoxei32_v_f16m4(_Float16 *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16m4(rs1, rs2, vs3, vl); } @@ -265,27 +265,27 @@ void test_vsoxei32_v_u64m8(uint64_t *rs1, vuint32m4_t rs2, vuint64m8_t vs3, return __riscv_vsoxei32_v_u64m8(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t rs2, +void test_vsoxei32_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint32m1_t rs2, +void test_vsoxei32_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint32m2_t rs2, +void test_vsoxei32_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint32m4_t rs2, +void test_vsoxei32_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16m2_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint32m8_t rs2, +void test_vsoxei32_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16m4_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxei64.c b/auto-generated/api-testing/vsoxei64.c index 1432e54f0..762cbb18f 100644 --- a/auto-generated/api-testing/vsoxei64.c +++ b/auto-generated/api-testing/vsoxei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxei64_v_f16mf4(float16_t *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, +void test_vsoxei64_v_f16mf4(_Float16 *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei64_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16mf2(float16_t *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, +void test_vsoxei64_v_f16mf2(_Float16 *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei64_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16m1(float16_t *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, +void test_vsoxei64_v_f16m1(_Float16 *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei64_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16m2(float16_t *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, +void test_vsoxei64_v_f16m2(_Float16 *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei64_v_f16m2(rs1, rs2, vs3, vl); } @@ -225,22 +225,22 @@ void test_vsoxei64_v_u64m8(uint64_t *rs1, vuint64m8_t rs2, vuint64m8_t vs3, return __riscv_vsoxei64_v_u64m8(rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint64m1_t rs2, +void test_vsoxei64_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei64_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint64m2_t rs2, +void test_vsoxei64_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei64_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint64m4_t rs2, +void test_vsoxei64_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei64_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint64m8_t rs2, +void test_vsoxei64_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei64_v_f16m2_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxei8.c b/auto-generated/api-testing/vsoxei8.c index 88ba30c35..d02c02b75 100644 --- a/auto-generated/api-testing/vsoxei8.c +++ b/auto-generated/api-testing/vsoxei8.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxei8_v_f16mf4(float16_t *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, +void test_vsoxei8_v_f16mf4(_Float16 *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16mf2(float16_t *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, +void test_vsoxei8_v_f16mf2(_Float16 *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m1(float16_t *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, +void test_vsoxei8_v_f16m1(_Float16 *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m2(float16_t *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, +void test_vsoxei8_v_f16m2(_Float16 *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16m2(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m4(float16_t *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, +void test_vsoxei8_v_f16m4(_Float16 *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16m4(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m8(float16_t *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, +void test_vsoxei8_v_f16m8(_Float16 *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16m8(rs1, rs2, vs3, vl); } @@ -300,32 +300,32 @@ void test_vsoxei8_v_u64m8(uint64_t *rs1, vuint8m1_t rs2, vuint64m8_t vs3, return __riscv_vsoxei8_v_u64m8(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t rs2, +void test_vsoxei8_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t rs2, +void test_vsoxei8_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t rs2, +void test_vsoxei8_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint8m1_t rs2, +void test_vsoxei8_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16m2_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint8m2_t rs2, +void test_vsoxei8_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16m4_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m8_m(vbool2_t vm, float16_t *rs1, vuint8m4_t rs2, +void test_vsoxei8_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16m8_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg2ei16.c b/auto-generated/api-testing/vsoxseg2ei16.c index 865af4b94..11ca7d158 100644 --- a/auto-generated/api-testing/vsoxseg2ei16.c +++ b/auto-generated/api-testing/vsoxseg2ei16.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg2ei16_v_f16mf4x2(float16_t *rs1, vuint16mf4_t vs2, +void test_vsoxseg2ei16_v_f16mf4x2(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16mf4x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16mf2x2(float16_t *rs1, vuint16mf2_t vs2, +void test_vsoxseg2ei16_v_f16mf2x2(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16mf2x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m1x2(float16_t *rs1, vuint16m1_t vs2, +void test_vsoxseg2ei16_v_f16m1x2(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16m1x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m2x2(float16_t *rs1, vuint16m2_t vs2, +void test_vsoxseg2ei16_v_f16m2x2(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16m2x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m4x2(float16_t *rs1, vuint16m4_t vs2, +void test_vsoxseg2ei16_v_f16m4x2(_Float16 *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16m4x2(rs1, vs2, vs3, vl); } @@ -245,30 +245,29 @@ void test_vsoxseg2ei16_v_u64m4x2(uint64_t *rs1, vuint16m1_t vs2, return __riscv_vsoxseg2ei16_v_u64m4x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg2ei16_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16mf4x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg2ei16_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16mf2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x2_t vs3, - size_t vl) { +void test_vsoxseg2ei16_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16m1x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, +void test_vsoxseg2ei16_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16m2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint16m4_t vs2, +void test_vsoxseg2ei16_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16m4x2_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg2ei32.c b/auto-generated/api-testing/vsoxseg2ei32.c index 054c21e58..42772fc6d 100644 --- a/auto-generated/api-testing/vsoxseg2ei32.c +++ b/auto-generated/api-testing/vsoxseg2ei32.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg2ei32_v_f16mf4x2(float16_t *rs1, vuint32mf2_t vs2, +void test_vsoxseg2ei32_v_f16mf4x2(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16mf4x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16mf2x2(float16_t *rs1, vuint32m1_t vs2, +void test_vsoxseg2ei32_v_f16mf2x2(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16mf2x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m1x2(float16_t *rs1, vuint32m2_t vs2, +void test_vsoxseg2ei32_v_f16m1x2(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16m1x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m2x2(float16_t *rs1, vuint32m4_t vs2, +void test_vsoxseg2ei32_v_f16m2x2(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16m2x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m4x2(float16_t *rs1, vuint32m8_t vs2, +void test_vsoxseg2ei32_v_f16m4x2(_Float16 *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16m4x2(rs1, vs2, vs3, vl); } @@ -235,30 +235,29 @@ void test_vsoxseg2ei32_v_u64m4x2(uint64_t *rs1, vuint32m2_t vs2, return __riscv_vsoxseg2ei32_v_u64m4x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg2ei32_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16mf4x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg2ei32_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16mf2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x2_t vs3, - size_t vl) { +void test_vsoxseg2ei32_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16m1x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, +void test_vsoxseg2ei32_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16m2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint32m8_t vs2, +void test_vsoxseg2ei32_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16m4x2_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg2ei64.c b/auto-generated/api-testing/vsoxseg2ei64.c index 189ff1384..aa31e9c56 100644 --- a/auto-generated/api-testing/vsoxseg2ei64.c +++ b/auto-generated/api-testing/vsoxseg2ei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg2ei64_v_f16mf4x2(float16_t *rs1, vuint64m1_t vs2, +void test_vsoxseg2ei64_v_f16mf4x2(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64_v_f16mf4x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16mf2x2(float16_t *rs1, vuint64m2_t vs2, +void test_vsoxseg2ei64_v_f16mf2x2(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64_v_f16mf2x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16m1x2(float16_t *rs1, vuint64m4_t vs2, +void test_vsoxseg2ei64_v_f16m1x2(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64_v_f16m1x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16m2x2(float16_t *rs1, vuint64m8_t vs2, +void test_vsoxseg2ei64_v_f16m2x2(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64_v_f16m2x2(rs1, vs2, vs3, vl); } @@ -210,25 +210,24 @@ void test_vsoxseg2ei64_v_u64m4x2(uint64_t *rs1, vuint64m4_t vs2, return __riscv_vsoxseg2ei64_v_u64m4x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg2ei64_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64_v_f16mf4x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg2ei64_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64_v_f16mf2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x2_t vs3, - size_t vl) { +void test_vsoxseg2ei64_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64_v_f16m1x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, +void test_vsoxseg2ei64_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64_v_f16m2x2_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg2ei8.c b/auto-generated/api-testing/vsoxseg2ei8.c index a46d4aacd..3b473db65 100644 --- a/auto-generated/api-testing/vsoxseg2ei8.c +++ b/auto-generated/api-testing/vsoxseg2ei8.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg2ei8_v_f16mf4x2(float16_t *rs1, vuint8mf8_t vs2, +void test_vsoxseg2ei8_v_f16mf4x2(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16mf4x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16mf2x2(float16_t *rs1, vuint8mf4_t vs2, +void test_vsoxseg2ei8_v_f16mf2x2(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16mf2x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m1x2(float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg2ei8_v_f16m1x2(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16m1x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m2x2(float16_t *rs1, vuint8m1_t vs2, +void test_vsoxseg2ei8_v_f16m2x2(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16m2x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m4x2(float16_t *rs1, vuint8m2_t vs2, +void test_vsoxseg2ei8_v_f16m4x2(_Float16 *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16m4x2(rs1, vs2, vs3, vl); } @@ -245,29 +245,27 @@ void test_vsoxseg2ei8_v_u64m4x2(uint64_t *rs1, vuint8mf2_t vs2, return __riscv_vsoxseg2ei8_v_u64m4x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x2_t vs3, - size_t vl) { +void test_vsoxseg2ei8_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16mf4x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x2_t vs3, - size_t vl) { +void test_vsoxseg2ei8_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16mf2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg2ei8_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16m1x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, +void test_vsoxseg2ei8_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16m2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint8m2_t vs2, +void test_vsoxseg2ei8_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16m4x2_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg3ei16.c b/auto-generated/api-testing/vsoxseg3ei16.c index 054a87b9e..af884fdf3 100644 --- a/auto-generated/api-testing/vsoxseg3ei16.c +++ b/auto-generated/api-testing/vsoxseg3ei16.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg3ei16_v_f16mf4x3(float16_t *rs1, vuint16mf4_t vs2, +void test_vsoxseg3ei16_v_f16mf4x3(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16_v_f16mf4x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16mf2x3(float16_t *rs1, vuint16mf2_t vs2, +void test_vsoxseg3ei16_v_f16mf2x3(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16_v_f16mf2x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16m1x3(float16_t *rs1, vuint16m1_t vs2, +void test_vsoxseg3ei16_v_f16m1x3(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16_v_f16m1x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16m2x3(float16_t *rs1, vuint16m2_t vs2, +void test_vsoxseg3ei16_v_f16m2x3(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16_v_f16m2x3(rs1, vs2, vs3, vl); } @@ -190,25 +190,24 @@ void test_vsoxseg3ei16_v_u64m2x3(uint64_t *rs1, vuint16mf2_t vs2, return __riscv_vsoxseg3ei16_v_u64m2x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg3ei16_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16_v_f16mf4x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg3ei16_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16_v_f16mf2x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x3_t vs3, - size_t vl) { +void test_vsoxseg3ei16_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16_v_f16m1x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, +void test_vsoxseg3ei16_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16_v_f16m2x3_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg3ei32.c b/auto-generated/api-testing/vsoxseg3ei32.c index 6fa54ead3..a90ba6700 100644 --- a/auto-generated/api-testing/vsoxseg3ei32.c +++ b/auto-generated/api-testing/vsoxseg3ei32.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg3ei32_v_f16mf4x3(float16_t *rs1, vuint32mf2_t vs2, +void test_vsoxseg3ei32_v_f16mf4x3(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32_v_f16mf4x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16mf2x3(float16_t *rs1, vuint32m1_t vs2, +void test_vsoxseg3ei32_v_f16mf2x3(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32_v_f16mf2x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16m1x3(float16_t *rs1, vuint32m2_t vs2, +void test_vsoxseg3ei32_v_f16m1x3(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32_v_f16m1x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16m2x3(float16_t *rs1, vuint32m4_t vs2, +void test_vsoxseg3ei32_v_f16m2x3(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32_v_f16m2x3(rs1, vs2, vs3, vl); } @@ -190,25 +190,24 @@ void test_vsoxseg3ei32_v_u64m2x3(uint64_t *rs1, vuint32m1_t vs2, return __riscv_vsoxseg3ei32_v_u64m2x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg3ei32_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32_v_f16mf4x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg3ei32_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32_v_f16mf2x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x3_t vs3, - size_t vl) { +void test_vsoxseg3ei32_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32_v_f16m1x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, +void test_vsoxseg3ei32_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32_v_f16m2x3_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg3ei64.c b/auto-generated/api-testing/vsoxseg3ei64.c index 1200a179c..49dba9235 100644 --- a/auto-generated/api-testing/vsoxseg3ei64.c +++ b/auto-generated/api-testing/vsoxseg3ei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg3ei64_v_f16mf4x3(float16_t *rs1, vuint64m1_t vs2, +void test_vsoxseg3ei64_v_f16mf4x3(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64_v_f16mf4x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16mf2x3(float16_t *rs1, vuint64m2_t vs2, +void test_vsoxseg3ei64_v_f16mf2x3(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64_v_f16mf2x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16m1x3(float16_t *rs1, vuint64m4_t vs2, +void test_vsoxseg3ei64_v_f16m1x3(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64_v_f16m1x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16m2x3(float16_t *rs1, vuint64m8_t vs2, +void test_vsoxseg3ei64_v_f16m2x3(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64_v_f16m2x3(rs1, vs2, vs3, vl); } @@ -180,25 +180,24 @@ void test_vsoxseg3ei64_v_u64m2x3(uint64_t *rs1, vuint64m2_t vs2, return __riscv_vsoxseg3ei64_v_u64m2x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg3ei64_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64_v_f16mf4x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg3ei64_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64_v_f16mf2x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x3_t vs3, - size_t vl) { +void test_vsoxseg3ei64_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64_v_f16m1x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, +void test_vsoxseg3ei64_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64_v_f16m2x3_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg3ei8.c b/auto-generated/api-testing/vsoxseg3ei8.c index 2f0fb054c..30da51ae6 100644 --- a/auto-generated/api-testing/vsoxseg3ei8.c +++ b/auto-generated/api-testing/vsoxseg3ei8.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg3ei8_v_f16mf4x3(float16_t *rs1, vuint8mf8_t vs2, +void test_vsoxseg3ei8_v_f16mf4x3(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8_v_f16mf4x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16mf2x3(float16_t *rs1, vuint8mf4_t vs2, +void test_vsoxseg3ei8_v_f16mf2x3(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8_v_f16mf2x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16m1x3(float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg3ei8_v_f16m1x3(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8_v_f16m1x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16m2x3(float16_t *rs1, vuint8m1_t vs2, +void test_vsoxseg3ei8_v_f16m2x3(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8_v_f16m2x3(rs1, vs2, vs3, vl); } @@ -190,24 +190,22 @@ void test_vsoxseg3ei8_v_u64m2x3(uint64_t *rs1, vuint8mf4_t vs2, return __riscv_vsoxseg3ei8_v_u64m2x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x3_t vs3, - size_t vl) { +void test_vsoxseg3ei8_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8_v_f16mf4x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x3_t vs3, - size_t vl) { +void test_vsoxseg3ei8_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8_v_f16mf2x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg3ei8_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8_v_f16m1x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, +void test_vsoxseg3ei8_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8_v_f16m2x3_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg4ei16.c b/auto-generated/api-testing/vsoxseg4ei16.c index de9320470..cdb750d4b 100644 --- a/auto-generated/api-testing/vsoxseg4ei16.c +++ b/auto-generated/api-testing/vsoxseg4ei16.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg4ei16_v_f16mf4x4(float16_t *rs1, vuint16mf4_t vs2, +void test_vsoxseg4ei16_v_f16mf4x4(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16_v_f16mf4x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16mf2x4(float16_t *rs1, vuint16mf2_t vs2, +void test_vsoxseg4ei16_v_f16mf2x4(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16_v_f16mf2x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16m1x4(float16_t *rs1, vuint16m1_t vs2, +void test_vsoxseg4ei16_v_f16m1x4(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16_v_f16m1x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16m2x4(float16_t *rs1, vuint16m2_t vs2, +void test_vsoxseg4ei16_v_f16m2x4(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16_v_f16m2x4(rs1, vs2, vs3, vl); } @@ -190,25 +190,24 @@ void test_vsoxseg4ei16_v_u64m2x4(uint64_t *rs1, vuint16mf2_t vs2, return __riscv_vsoxseg4ei16_v_u64m2x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg4ei16_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16_v_f16mf4x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg4ei16_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16_v_f16mf2x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x4_t vs3, - size_t vl) { +void test_vsoxseg4ei16_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16_v_f16m1x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, +void test_vsoxseg4ei16_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16_v_f16m2x4_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg4ei32.c b/auto-generated/api-testing/vsoxseg4ei32.c index 1021a80e4..06310c9e5 100644 --- a/auto-generated/api-testing/vsoxseg4ei32.c +++ b/auto-generated/api-testing/vsoxseg4ei32.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg4ei32_v_f16mf4x4(float16_t *rs1, vuint32mf2_t vs2, +void test_vsoxseg4ei32_v_f16mf4x4(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32_v_f16mf4x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16mf2x4(float16_t *rs1, vuint32m1_t vs2, +void test_vsoxseg4ei32_v_f16mf2x4(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32_v_f16mf2x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16m1x4(float16_t *rs1, vuint32m2_t vs2, +void test_vsoxseg4ei32_v_f16m1x4(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32_v_f16m1x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16m2x4(float16_t *rs1, vuint32m4_t vs2, +void test_vsoxseg4ei32_v_f16m2x4(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32_v_f16m2x4(rs1, vs2, vs3, vl); } @@ -190,25 +190,24 @@ void test_vsoxseg4ei32_v_u64m2x4(uint64_t *rs1, vuint32m1_t vs2, return __riscv_vsoxseg4ei32_v_u64m2x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg4ei32_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32_v_f16mf4x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg4ei32_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32_v_f16mf2x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x4_t vs3, - size_t vl) { +void test_vsoxseg4ei32_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32_v_f16m1x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, +void test_vsoxseg4ei32_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32_v_f16m2x4_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg4ei64.c b/auto-generated/api-testing/vsoxseg4ei64.c index 2110b9c3a..50da0bd22 100644 --- a/auto-generated/api-testing/vsoxseg4ei64.c +++ b/auto-generated/api-testing/vsoxseg4ei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg4ei64_v_f16mf4x4(float16_t *rs1, vuint64m1_t vs2, +void test_vsoxseg4ei64_v_f16mf4x4(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64_v_f16mf4x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16mf2x4(float16_t *rs1, vuint64m2_t vs2, +void test_vsoxseg4ei64_v_f16mf2x4(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64_v_f16mf2x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16m1x4(float16_t *rs1, vuint64m4_t vs2, +void test_vsoxseg4ei64_v_f16m1x4(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64_v_f16m1x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16m2x4(float16_t *rs1, vuint64m8_t vs2, +void test_vsoxseg4ei64_v_f16m2x4(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64_v_f16m2x4(rs1, vs2, vs3, vl); } @@ -180,25 +180,24 @@ void test_vsoxseg4ei64_v_u64m2x4(uint64_t *rs1, vuint64m2_t vs2, return __riscv_vsoxseg4ei64_v_u64m2x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg4ei64_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64_v_f16mf4x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg4ei64_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64_v_f16mf2x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x4_t vs3, - size_t vl) { +void test_vsoxseg4ei64_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64_v_f16m1x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, +void test_vsoxseg4ei64_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64_v_f16m2x4_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg4ei8.c b/auto-generated/api-testing/vsoxseg4ei8.c index 5b2beadf6..1e743e84a 100644 --- a/auto-generated/api-testing/vsoxseg4ei8.c +++ b/auto-generated/api-testing/vsoxseg4ei8.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg4ei8_v_f16mf4x4(float16_t *rs1, vuint8mf8_t vs2, +void test_vsoxseg4ei8_v_f16mf4x4(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8_v_f16mf4x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16mf2x4(float16_t *rs1, vuint8mf4_t vs2, +void test_vsoxseg4ei8_v_f16mf2x4(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8_v_f16mf2x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16m1x4(float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg4ei8_v_f16m1x4(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8_v_f16m1x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16m2x4(float16_t *rs1, vuint8m1_t vs2, +void test_vsoxseg4ei8_v_f16m2x4(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8_v_f16m2x4(rs1, vs2, vs3, vl); } @@ -190,24 +190,22 @@ void test_vsoxseg4ei8_v_u64m2x4(uint64_t *rs1, vuint8mf4_t vs2, return __riscv_vsoxseg4ei8_v_u64m2x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x4_t vs3, - size_t vl) { +void test_vsoxseg4ei8_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8_v_f16mf4x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x4_t vs3, - size_t vl) { +void test_vsoxseg4ei8_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8_v_f16mf2x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg4ei8_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8_v_f16m1x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, +void test_vsoxseg4ei8_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8_v_f16m2x4_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg5ei16.c b/auto-generated/api-testing/vsoxseg5ei16.c index e1f4f05be..df575c4e7 100644 --- a/auto-generated/api-testing/vsoxseg5ei16.c +++ b/auto-generated/api-testing/vsoxseg5ei16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg5ei16_v_f16mf4x5(float16_t *rs1, vuint16mf4_t vs2, +void test_vsoxseg5ei16_v_f16mf4x5(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16_v_f16mf4x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16mf2x5(float16_t *rs1, vuint16mf2_t vs2, +void test_vsoxseg5ei16_v_f16mf2x5(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16_v_f16mf2x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16m1x5(float16_t *rs1, vuint16m1_t vs2, +void test_vsoxseg5ei16_v_f16m1x5(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16_v_f16m1x5(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg5ei16_v_u64m1x5(uint64_t *rs1, vuint16mf4_t vs2, return __riscv_vsoxseg5ei16_v_u64m1x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg5ei16_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16_v_f16mf4x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg5ei16_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16_v_f16mf2x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x5_t vs3, - size_t vl) { +void test_vsoxseg5ei16_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16_v_f16m1x5_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg5ei32.c b/auto-generated/api-testing/vsoxseg5ei32.c index 232438516..844c0e02b 100644 --- a/auto-generated/api-testing/vsoxseg5ei32.c +++ b/auto-generated/api-testing/vsoxseg5ei32.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg5ei32_v_f16mf4x5(float16_t *rs1, vuint32mf2_t vs2, +void test_vsoxseg5ei32_v_f16mf4x5(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32_v_f16mf4x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16mf2x5(float16_t *rs1, vuint32m1_t vs2, +void test_vsoxseg5ei32_v_f16mf2x5(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32_v_f16mf2x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16m1x5(float16_t *rs1, vuint32m2_t vs2, +void test_vsoxseg5ei32_v_f16m1x5(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32_v_f16m1x5(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg5ei32_v_u64m1x5(uint64_t *rs1, vuint32mf2_t vs2, return __riscv_vsoxseg5ei32_v_u64m1x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg5ei32_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32_v_f16mf4x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg5ei32_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32_v_f16mf2x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x5_t vs3, - size_t vl) { +void test_vsoxseg5ei32_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32_v_f16m1x5_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg5ei64.c b/auto-generated/api-testing/vsoxseg5ei64.c index 368bf57d0..2ff488919 100644 --- a/auto-generated/api-testing/vsoxseg5ei64.c +++ b/auto-generated/api-testing/vsoxseg5ei64.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg5ei64_v_f16mf4x5(float16_t *rs1, vuint64m1_t vs2, +void test_vsoxseg5ei64_v_f16mf4x5(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64_v_f16mf4x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16mf2x5(float16_t *rs1, vuint64m2_t vs2, +void test_vsoxseg5ei64_v_f16mf2x5(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64_v_f16mf2x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16m1x5(float16_t *rs1, vuint64m4_t vs2, +void test_vsoxseg5ei64_v_f16m1x5(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64_v_f16m1x5(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg5ei64_v_u64m1x5(uint64_t *rs1, vuint64m1_t vs2, return __riscv_vsoxseg5ei64_v_u64m1x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg5ei64_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64_v_f16mf4x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg5ei64_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64_v_f16mf2x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x5_t vs3, - size_t vl) { +void test_vsoxseg5ei64_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64_v_f16m1x5_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg5ei8.c b/auto-generated/api-testing/vsoxseg5ei8.c index 582e3bfe5..5f60d3654 100644 --- a/auto-generated/api-testing/vsoxseg5ei8.c +++ b/auto-generated/api-testing/vsoxseg5ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg5ei8_v_f16mf4x5(float16_t *rs1, vuint8mf8_t vs2, +void test_vsoxseg5ei8_v_f16mf4x5(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8_v_f16mf4x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16mf2x5(float16_t *rs1, vuint8mf4_t vs2, +void test_vsoxseg5ei8_v_f16mf2x5(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8_v_f16mf2x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16m1x5(float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg5ei8_v_f16m1x5(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8_v_f16m1x5(rs1, vs2, vs3, vl); } @@ -135,19 +135,17 @@ void test_vsoxseg5ei8_v_u64m1x5(uint64_t *rs1, vuint8mf8_t vs2, return __riscv_vsoxseg5ei8_v_u64m1x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x5_t vs3, - size_t vl) { +void test_vsoxseg5ei8_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8_v_f16mf4x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x5_t vs3, - size_t vl) { +void test_vsoxseg5ei8_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8_v_f16mf2x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg5ei8_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8_v_f16m1x5_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg6ei16.c b/auto-generated/api-testing/vsoxseg6ei16.c index 981d270a5..57c3b8dde 100644 --- a/auto-generated/api-testing/vsoxseg6ei16.c +++ b/auto-generated/api-testing/vsoxseg6ei16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg6ei16_v_f16mf4x6(float16_t *rs1, vuint16mf4_t vs2, +void test_vsoxseg6ei16_v_f16mf4x6(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16_v_f16mf4x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16mf2x6(float16_t *rs1, vuint16mf2_t vs2, +void test_vsoxseg6ei16_v_f16mf2x6(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16_v_f16mf2x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16m1x6(float16_t *rs1, vuint16m1_t vs2, +void test_vsoxseg6ei16_v_f16m1x6(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16_v_f16m1x6(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg6ei16_v_u64m1x6(uint64_t *rs1, vuint16mf4_t vs2, return __riscv_vsoxseg6ei16_v_u64m1x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg6ei16_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16_v_f16mf4x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg6ei16_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16_v_f16mf2x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x6_t vs3, - size_t vl) { +void test_vsoxseg6ei16_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16_v_f16m1x6_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg6ei32.c b/auto-generated/api-testing/vsoxseg6ei32.c index a670ecf58..e56181836 100644 --- a/auto-generated/api-testing/vsoxseg6ei32.c +++ b/auto-generated/api-testing/vsoxseg6ei32.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg6ei32_v_f16mf4x6(float16_t *rs1, vuint32mf2_t vs2, +void test_vsoxseg6ei32_v_f16mf4x6(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32_v_f16mf4x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16mf2x6(float16_t *rs1, vuint32m1_t vs2, +void test_vsoxseg6ei32_v_f16mf2x6(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32_v_f16mf2x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16m1x6(float16_t *rs1, vuint32m2_t vs2, +void test_vsoxseg6ei32_v_f16m1x6(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32_v_f16m1x6(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg6ei32_v_u64m1x6(uint64_t *rs1, vuint32mf2_t vs2, return __riscv_vsoxseg6ei32_v_u64m1x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg6ei32_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32_v_f16mf4x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg6ei32_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32_v_f16mf2x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x6_t vs3, - size_t vl) { +void test_vsoxseg6ei32_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32_v_f16m1x6_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg6ei64.c b/auto-generated/api-testing/vsoxseg6ei64.c index 42fa8b390..556c94577 100644 --- a/auto-generated/api-testing/vsoxseg6ei64.c +++ b/auto-generated/api-testing/vsoxseg6ei64.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg6ei64_v_f16mf4x6(float16_t *rs1, vuint64m1_t vs2, +void test_vsoxseg6ei64_v_f16mf4x6(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64_v_f16mf4x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16mf2x6(float16_t *rs1, vuint64m2_t vs2, +void test_vsoxseg6ei64_v_f16mf2x6(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64_v_f16mf2x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16m1x6(float16_t *rs1, vuint64m4_t vs2, +void test_vsoxseg6ei64_v_f16m1x6(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64_v_f16m1x6(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg6ei64_v_u64m1x6(uint64_t *rs1, vuint64m1_t vs2, return __riscv_vsoxseg6ei64_v_u64m1x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg6ei64_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64_v_f16mf4x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg6ei64_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64_v_f16mf2x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x6_t vs3, - size_t vl) { +void test_vsoxseg6ei64_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64_v_f16m1x6_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg6ei8.c b/auto-generated/api-testing/vsoxseg6ei8.c index 1f2f96482..bec4d2da4 100644 --- a/auto-generated/api-testing/vsoxseg6ei8.c +++ b/auto-generated/api-testing/vsoxseg6ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg6ei8_v_f16mf4x6(float16_t *rs1, vuint8mf8_t vs2, +void test_vsoxseg6ei8_v_f16mf4x6(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8_v_f16mf4x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16mf2x6(float16_t *rs1, vuint8mf4_t vs2, +void test_vsoxseg6ei8_v_f16mf2x6(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8_v_f16mf2x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16m1x6(float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg6ei8_v_f16m1x6(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8_v_f16m1x6(rs1, vs2, vs3, vl); } @@ -135,19 +135,17 @@ void test_vsoxseg6ei8_v_u64m1x6(uint64_t *rs1, vuint8mf8_t vs2, return __riscv_vsoxseg6ei8_v_u64m1x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x6_t vs3, - size_t vl) { +void test_vsoxseg6ei8_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8_v_f16mf4x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x6_t vs3, - size_t vl) { +void test_vsoxseg6ei8_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8_v_f16mf2x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg6ei8_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8_v_f16m1x6_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg7ei16.c b/auto-generated/api-testing/vsoxseg7ei16.c index d9747038f..a7bc5b700 100644 --- a/auto-generated/api-testing/vsoxseg7ei16.c +++ b/auto-generated/api-testing/vsoxseg7ei16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg7ei16_v_f16mf4x7(float16_t *rs1, vuint16mf4_t vs2, +void test_vsoxseg7ei16_v_f16mf4x7(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16_v_f16mf4x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16mf2x7(float16_t *rs1, vuint16mf2_t vs2, +void test_vsoxseg7ei16_v_f16mf2x7(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16_v_f16mf2x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16m1x7(float16_t *rs1, vuint16m1_t vs2, +void test_vsoxseg7ei16_v_f16m1x7(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16_v_f16m1x7(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg7ei16_v_u64m1x7(uint64_t *rs1, vuint16mf4_t vs2, return __riscv_vsoxseg7ei16_v_u64m1x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg7ei16_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16_v_f16mf4x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg7ei16_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16_v_f16mf2x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x7_t vs3, - size_t vl) { +void test_vsoxseg7ei16_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16_v_f16m1x7_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg7ei32.c b/auto-generated/api-testing/vsoxseg7ei32.c index 79665055b..103df3d37 100644 --- a/auto-generated/api-testing/vsoxseg7ei32.c +++ b/auto-generated/api-testing/vsoxseg7ei32.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg7ei32_v_f16mf4x7(float16_t *rs1, vuint32mf2_t vs2, +void test_vsoxseg7ei32_v_f16mf4x7(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32_v_f16mf4x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16mf2x7(float16_t *rs1, vuint32m1_t vs2, +void test_vsoxseg7ei32_v_f16mf2x7(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32_v_f16mf2x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16m1x7(float16_t *rs1, vuint32m2_t vs2, +void test_vsoxseg7ei32_v_f16m1x7(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32_v_f16m1x7(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg7ei32_v_u64m1x7(uint64_t *rs1, vuint32mf2_t vs2, return __riscv_vsoxseg7ei32_v_u64m1x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg7ei32_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32_v_f16mf4x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg7ei32_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32_v_f16mf2x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x7_t vs3, - size_t vl) { +void test_vsoxseg7ei32_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32_v_f16m1x7_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg7ei64.c b/auto-generated/api-testing/vsoxseg7ei64.c index 537fe415a..5af3fbb84 100644 --- a/auto-generated/api-testing/vsoxseg7ei64.c +++ b/auto-generated/api-testing/vsoxseg7ei64.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg7ei64_v_f16mf4x7(float16_t *rs1, vuint64m1_t vs2, +void test_vsoxseg7ei64_v_f16mf4x7(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64_v_f16mf4x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16mf2x7(float16_t *rs1, vuint64m2_t vs2, +void test_vsoxseg7ei64_v_f16mf2x7(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64_v_f16mf2x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16m1x7(float16_t *rs1, vuint64m4_t vs2, +void test_vsoxseg7ei64_v_f16m1x7(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64_v_f16m1x7(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg7ei64_v_u64m1x7(uint64_t *rs1, vuint64m1_t vs2, return __riscv_vsoxseg7ei64_v_u64m1x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg7ei64_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64_v_f16mf4x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg7ei64_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64_v_f16mf2x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x7_t vs3, - size_t vl) { +void test_vsoxseg7ei64_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64_v_f16m1x7_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg7ei8.c b/auto-generated/api-testing/vsoxseg7ei8.c index daa34c116..3978deb1b 100644 --- a/auto-generated/api-testing/vsoxseg7ei8.c +++ b/auto-generated/api-testing/vsoxseg7ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg7ei8_v_f16mf4x7(float16_t *rs1, vuint8mf8_t vs2, +void test_vsoxseg7ei8_v_f16mf4x7(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8_v_f16mf4x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16mf2x7(float16_t *rs1, vuint8mf4_t vs2, +void test_vsoxseg7ei8_v_f16mf2x7(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8_v_f16mf2x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16m1x7(float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg7ei8_v_f16m1x7(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8_v_f16m1x7(rs1, vs2, vs3, vl); } @@ -135,19 +135,17 @@ void test_vsoxseg7ei8_v_u64m1x7(uint64_t *rs1, vuint8mf8_t vs2, return __riscv_vsoxseg7ei8_v_u64m1x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x7_t vs3, - size_t vl) { +void test_vsoxseg7ei8_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8_v_f16mf4x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x7_t vs3, - size_t vl) { +void test_vsoxseg7ei8_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8_v_f16mf2x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg7ei8_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8_v_f16m1x7_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg8ei16.c b/auto-generated/api-testing/vsoxseg8ei16.c index cbb3936a9..23bd39903 100644 --- a/auto-generated/api-testing/vsoxseg8ei16.c +++ b/auto-generated/api-testing/vsoxseg8ei16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg8ei16_v_f16mf4x8(float16_t *rs1, vuint16mf4_t vs2, +void test_vsoxseg8ei16_v_f16mf4x8(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16_v_f16mf4x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16mf2x8(float16_t *rs1, vuint16mf2_t vs2, +void test_vsoxseg8ei16_v_f16mf2x8(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16_v_f16mf2x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16m1x8(float16_t *rs1, vuint16m1_t vs2, +void test_vsoxseg8ei16_v_f16m1x8(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16_v_f16m1x8(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg8ei16_v_u64m1x8(uint64_t *rs1, vuint16mf4_t vs2, return __riscv_vsoxseg8ei16_v_u64m1x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg8ei16_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16_v_f16mf4x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg8ei16_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16_v_f16mf2x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x8_t vs3, - size_t vl) { +void test_vsoxseg8ei16_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16_v_f16m1x8_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg8ei32.c b/auto-generated/api-testing/vsoxseg8ei32.c index 7305ce76b..bde98448b 100644 --- a/auto-generated/api-testing/vsoxseg8ei32.c +++ b/auto-generated/api-testing/vsoxseg8ei32.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg8ei32_v_f16mf4x8(float16_t *rs1, vuint32mf2_t vs2, +void test_vsoxseg8ei32_v_f16mf4x8(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32_v_f16mf4x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16mf2x8(float16_t *rs1, vuint32m1_t vs2, +void test_vsoxseg8ei32_v_f16mf2x8(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32_v_f16mf2x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16m1x8(float16_t *rs1, vuint32m2_t vs2, +void test_vsoxseg8ei32_v_f16m1x8(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32_v_f16m1x8(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg8ei32_v_u64m1x8(uint64_t *rs1, vuint32mf2_t vs2, return __riscv_vsoxseg8ei32_v_u64m1x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg8ei32_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32_v_f16mf4x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg8ei32_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32_v_f16mf2x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x8_t vs3, - size_t vl) { +void test_vsoxseg8ei32_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32_v_f16m1x8_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg8ei64.c b/auto-generated/api-testing/vsoxseg8ei64.c index b92c75cbc..8fb4928a7 100644 --- a/auto-generated/api-testing/vsoxseg8ei64.c +++ b/auto-generated/api-testing/vsoxseg8ei64.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg8ei64_v_f16mf4x8(float16_t *rs1, vuint64m1_t vs2, +void test_vsoxseg8ei64_v_f16mf4x8(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64_v_f16mf4x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16mf2x8(float16_t *rs1, vuint64m2_t vs2, +void test_vsoxseg8ei64_v_f16mf2x8(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64_v_f16mf2x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16m1x8(float16_t *rs1, vuint64m4_t vs2, +void test_vsoxseg8ei64_v_f16m1x8(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64_v_f16m1x8(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg8ei64_v_u64m1x8(uint64_t *rs1, vuint64m1_t vs2, return __riscv_vsoxseg8ei64_v_u64m1x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg8ei64_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64_v_f16mf4x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg8ei64_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64_v_f16mf2x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x8_t vs3, - size_t vl) { +void test_vsoxseg8ei64_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64_v_f16m1x8_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsoxseg8ei8.c b/auto-generated/api-testing/vsoxseg8ei8.c index e9e0a8fce..8fce75f9d 100644 --- a/auto-generated/api-testing/vsoxseg8ei8.c +++ b/auto-generated/api-testing/vsoxseg8ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg8ei8_v_f16mf4x8(float16_t *rs1, vuint8mf8_t vs2, +void test_vsoxseg8ei8_v_f16mf4x8(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8_v_f16mf4x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16mf2x8(float16_t *rs1, vuint8mf4_t vs2, +void test_vsoxseg8ei8_v_f16mf2x8(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8_v_f16mf2x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16m1x8(float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg8ei8_v_f16m1x8(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8_v_f16m1x8(rs1, vs2, vs3, vl); } @@ -135,19 +135,17 @@ void test_vsoxseg8ei8_v_u64m1x8(uint64_t *rs1, vuint8mf8_t vs2, return __riscv_vsoxseg8ei8_v_u64m1x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x8_t vs3, - size_t vl) { +void test_vsoxseg8ei8_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8_v_f16mf4x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x8_t vs3, - size_t vl) { +void test_vsoxseg8ei8_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8_v_f16mf2x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg8ei8_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8_v_f16m1x8_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsse16.c b/auto-generated/api-testing/vsse16.c index 6c4a04f43..1c0915168 100644 --- a/auto-generated/api-testing/vsse16.c +++ b/auto-generated/api-testing/vsse16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsse16_v_f16mf4(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4_t vs3, +void test_vsse16_v_f16mf4(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsse16_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16mf2(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2_t vs3, +void test_vsse16_v_f16mf2(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsse16_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m1(float16_t *rs1, ptrdiff_t rs2, vfloat16m1_t vs3, +void test_vsse16_v_f16m1(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsse16_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m2(float16_t *rs1, ptrdiff_t rs2, vfloat16m2_t vs3, +void test_vsse16_v_f16m2(_Float16 *rs1, ptrdiff_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsse16_v_f16m2(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m4(float16_t *rs1, ptrdiff_t rs2, vfloat16m4_t vs3, +void test_vsse16_v_f16m4(_Float16 *rs1, ptrdiff_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsse16_v_f16m4(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m8(float16_t *rs1, ptrdiff_t rs2, vfloat16m8_t vs3, +void test_vsse16_v_f16m8(_Float16 *rs1, ptrdiff_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsse16_v_f16m8(rs1, rs2, vs3, vl); } @@ -95,32 +95,32 @@ void test_vsse16_v_u16m8(uint16_t *rs1, ptrdiff_t rs2, vuint16m8_t vs3, return __riscv_vsse16_v_u16m8(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16mf4_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vsse16_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsse16_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16mf2_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vsse16_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsse16_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m1_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vsse16_v_f16m1_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsse16_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m2_m(vbool8_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vsse16_v_f16m2_m(vbool8_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsse16_v_f16m2_m(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m4_m(vbool4_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vsse16_v_f16m4_m(vbool4_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsse16_v_f16m4_m(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m8_m(vbool2_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vsse16_v_f16m8_m(vbool2_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsse16_v_f16m8_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsseg2e16.c b/auto-generated/api-testing/vsseg2e16.c index 4fb280cbd..220ae5dae 100644 --- a/auto-generated/api-testing/vsseg2e16.c +++ b/auto-generated/api-testing/vsseg2e16.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg2e16_v_f16mf4x2(float16_t *rs1, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16mf4x2(_Float16 *rs1, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16mf4x2(rs1, vs3, vl); } -void test_vsseg2e16_v_f16mf2x2(float16_t *rs1, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16mf2x2(_Float16 *rs1, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16mf2x2(rs1, vs3, vl); } -void test_vsseg2e16_v_f16m1x2(float16_t *rs1, vfloat16m1x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m1x2(_Float16 *rs1, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16m1x2(rs1, vs3, vl); } -void test_vsseg2e16_v_f16m2x2(float16_t *rs1, vfloat16m2x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m2x2(_Float16 *rs1, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16m2x2(rs1, vs3, vl); } -void test_vsseg2e16_v_f16m4x2(float16_t *rs1, vfloat16m4x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m4x2(_Float16 *rs1, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16m4x2(rs1, vs3, vl); } @@ -65,27 +65,27 @@ void test_vsseg2e16_v_u16m4x2(uint16_t *rs1, vuint16m4x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_u16m4x2(rs1, vs3, vl); } -void test_vsseg2e16_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, +void test_vsseg2e16_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16mf4x2_m(vm, rs1, vs3, vl); } -void test_vsseg2e16_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, +void test_vsseg2e16_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16mf2x2_m(vm, rs1, vs3, vl); } -void test_vsseg2e16_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, - vfloat16m1x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x2_t vs3, + size_t vl) { return __riscv_vsseg2e16_v_f16m1x2_m(vm, rs1, vs3, vl); } -void test_vsseg2e16_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vfloat16m2x2_t vs3, +void test_vsseg2e16_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16m2x2_m(vm, rs1, vs3, vl); } -void test_vsseg2e16_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vfloat16m4x2_t vs3, +void test_vsseg2e16_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16m4x2_m(vm, rs1, vs3, vl); } diff --git a/auto-generated/api-testing/vsseg3e16.c b/auto-generated/api-testing/vsseg3e16.c index 9a55603a4..47011652e 100644 --- a/auto-generated/api-testing/vsseg3e16.c +++ b/auto-generated/api-testing/vsseg3e16.c @@ -5,19 +5,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg3e16_v_f16mf4x3(float16_t *rs1, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16mf4x3(_Float16 *rs1, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_f16mf4x3(rs1, vs3, vl); } -void test_vsseg3e16_v_f16mf2x3(float16_t *rs1, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16mf2x3(_Float16 *rs1, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_f16mf2x3(rs1, vs3, vl); } -void test_vsseg3e16_v_f16m1x3(float16_t *rs1, vfloat16m1x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16m1x3(_Float16 *rs1, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_f16m1x3(rs1, vs3, vl); } -void test_vsseg3e16_v_f16m2x3(float16_t *rs1, vfloat16m2x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16m2x3(_Float16 *rs1, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_f16m2x3(rs1, vs3, vl); } @@ -53,22 +53,22 @@ void test_vsseg3e16_v_u16m2x3(uint16_t *rs1, vuint16m2x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_u16m2x3(rs1, vs3, vl); } -void test_vsseg3e16_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, +void test_vsseg3e16_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_f16mf4x3_m(vm, rs1, vs3, vl); } -void test_vsseg3e16_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, +void test_vsseg3e16_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_f16mf2x3_m(vm, rs1, vs3, vl); } -void test_vsseg3e16_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, - vfloat16m1x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x3_t vs3, + size_t vl) { return __riscv_vsseg3e16_v_f16m1x3_m(vm, rs1, vs3, vl); } -void test_vsseg3e16_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vfloat16m2x3_t vs3, +void test_vsseg3e16_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_f16m2x3_m(vm, rs1, vs3, vl); } diff --git a/auto-generated/api-testing/vsseg4e16.c b/auto-generated/api-testing/vsseg4e16.c index 3679f841b..06b4bd670 100644 --- a/auto-generated/api-testing/vsseg4e16.c +++ b/auto-generated/api-testing/vsseg4e16.c @@ -5,19 +5,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg4e16_v_f16mf4x4(float16_t *rs1, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16mf4x4(_Float16 *rs1, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_f16mf4x4(rs1, vs3, vl); } -void test_vsseg4e16_v_f16mf2x4(float16_t *rs1, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16mf2x4(_Float16 *rs1, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_f16mf2x4(rs1, vs3, vl); } -void test_vsseg4e16_v_f16m1x4(float16_t *rs1, vfloat16m1x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16m1x4(_Float16 *rs1, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_f16m1x4(rs1, vs3, vl); } -void test_vsseg4e16_v_f16m2x4(float16_t *rs1, vfloat16m2x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16m2x4(_Float16 *rs1, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_f16m2x4(rs1, vs3, vl); } @@ -53,22 +53,22 @@ void test_vsseg4e16_v_u16m2x4(uint16_t *rs1, vuint16m2x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_u16m2x4(rs1, vs3, vl); } -void test_vsseg4e16_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, +void test_vsseg4e16_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_f16mf4x4_m(vm, rs1, vs3, vl); } -void test_vsseg4e16_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, +void test_vsseg4e16_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_f16mf2x4_m(vm, rs1, vs3, vl); } -void test_vsseg4e16_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, - vfloat16m1x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x4_t vs3, + size_t vl) { return __riscv_vsseg4e16_v_f16m1x4_m(vm, rs1, vs3, vl); } -void test_vsseg4e16_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vfloat16m2x4_t vs3, +void test_vsseg4e16_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_f16m2x4_m(vm, rs1, vs3, vl); } diff --git a/auto-generated/api-testing/vsseg5e16.c b/auto-generated/api-testing/vsseg5e16.c index 6a7bb41b0..f0ca66a5b 100644 --- a/auto-generated/api-testing/vsseg5e16.c +++ b/auto-generated/api-testing/vsseg5e16.c @@ -5,15 +5,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg5e16_v_f16mf4x5(float16_t *rs1, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16mf4x5(_Float16 *rs1, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsseg5e16_v_f16mf4x5(rs1, vs3, vl); } -void test_vsseg5e16_v_f16mf2x5(float16_t *rs1, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16mf2x5(_Float16 *rs1, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsseg5e16_v_f16mf2x5(rs1, vs3, vl); } -void test_vsseg5e16_v_f16m1x5(float16_t *rs1, vfloat16m1x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16m1x5(_Float16 *rs1, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsseg5e16_v_f16m1x5(rs1, vs3, vl); } @@ -41,18 +41,18 @@ void test_vsseg5e16_v_u16m1x5(uint16_t *rs1, vuint16m1x5_t vs3, size_t vl) { return __riscv_vsseg5e16_v_u16m1x5(rs1, vs3, vl); } -void test_vsseg5e16_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, +void test_vsseg5e16_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsseg5e16_v_f16mf4x5_m(vm, rs1, vs3, vl); } -void test_vsseg5e16_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, +void test_vsseg5e16_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsseg5e16_v_f16mf2x5_m(vm, rs1, vs3, vl); } -void test_vsseg5e16_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, - vfloat16m1x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x5_t vs3, + size_t vl) { return __riscv_vsseg5e16_v_f16m1x5_m(vm, rs1, vs3, vl); } diff --git a/auto-generated/api-testing/vsseg6e16.c b/auto-generated/api-testing/vsseg6e16.c index 1ee3dc208..f1349a654 100644 --- a/auto-generated/api-testing/vsseg6e16.c +++ b/auto-generated/api-testing/vsseg6e16.c @@ -5,15 +5,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg6e16_v_f16mf4x6(float16_t *rs1, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16mf4x6(_Float16 *rs1, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsseg6e16_v_f16mf4x6(rs1, vs3, vl); } -void test_vsseg6e16_v_f16mf2x6(float16_t *rs1, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16mf2x6(_Float16 *rs1, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsseg6e16_v_f16mf2x6(rs1, vs3, vl); } -void test_vsseg6e16_v_f16m1x6(float16_t *rs1, vfloat16m1x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16m1x6(_Float16 *rs1, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsseg6e16_v_f16m1x6(rs1, vs3, vl); } @@ -41,18 +41,18 @@ void test_vsseg6e16_v_u16m1x6(uint16_t *rs1, vuint16m1x6_t vs3, size_t vl) { return __riscv_vsseg6e16_v_u16m1x6(rs1, vs3, vl); } -void test_vsseg6e16_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, +void test_vsseg6e16_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsseg6e16_v_f16mf4x6_m(vm, rs1, vs3, vl); } -void test_vsseg6e16_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, +void test_vsseg6e16_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsseg6e16_v_f16mf2x6_m(vm, rs1, vs3, vl); } -void test_vsseg6e16_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, - vfloat16m1x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x6_t vs3, + size_t vl) { return __riscv_vsseg6e16_v_f16m1x6_m(vm, rs1, vs3, vl); } diff --git a/auto-generated/api-testing/vsseg7e16.c b/auto-generated/api-testing/vsseg7e16.c index 61be2a6be..3fe17a663 100644 --- a/auto-generated/api-testing/vsseg7e16.c +++ b/auto-generated/api-testing/vsseg7e16.c @@ -5,15 +5,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg7e16_v_f16mf4x7(float16_t *rs1, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16mf4x7(_Float16 *rs1, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsseg7e16_v_f16mf4x7(rs1, vs3, vl); } -void test_vsseg7e16_v_f16mf2x7(float16_t *rs1, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16mf2x7(_Float16 *rs1, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsseg7e16_v_f16mf2x7(rs1, vs3, vl); } -void test_vsseg7e16_v_f16m1x7(float16_t *rs1, vfloat16m1x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16m1x7(_Float16 *rs1, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsseg7e16_v_f16m1x7(rs1, vs3, vl); } @@ -41,18 +41,18 @@ void test_vsseg7e16_v_u16m1x7(uint16_t *rs1, vuint16m1x7_t vs3, size_t vl) { return __riscv_vsseg7e16_v_u16m1x7(rs1, vs3, vl); } -void test_vsseg7e16_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, +void test_vsseg7e16_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsseg7e16_v_f16mf4x7_m(vm, rs1, vs3, vl); } -void test_vsseg7e16_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, +void test_vsseg7e16_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsseg7e16_v_f16mf2x7_m(vm, rs1, vs3, vl); } -void test_vsseg7e16_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, - vfloat16m1x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x7_t vs3, + size_t vl) { return __riscv_vsseg7e16_v_f16m1x7_m(vm, rs1, vs3, vl); } diff --git a/auto-generated/api-testing/vsseg8e16.c b/auto-generated/api-testing/vsseg8e16.c index 0d02686c8..26b9232a7 100644 --- a/auto-generated/api-testing/vsseg8e16.c +++ b/auto-generated/api-testing/vsseg8e16.c @@ -5,15 +5,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg8e16_v_f16mf4x8(float16_t *rs1, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16mf4x8(_Float16 *rs1, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsseg8e16_v_f16mf4x8(rs1, vs3, vl); } -void test_vsseg8e16_v_f16mf2x8(float16_t *rs1, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16mf2x8(_Float16 *rs1, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsseg8e16_v_f16mf2x8(rs1, vs3, vl); } -void test_vsseg8e16_v_f16m1x8(float16_t *rs1, vfloat16m1x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16m1x8(_Float16 *rs1, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsseg8e16_v_f16m1x8(rs1, vs3, vl); } @@ -41,18 +41,18 @@ void test_vsseg8e16_v_u16m1x8(uint16_t *rs1, vuint16m1x8_t vs3, size_t vl) { return __riscv_vsseg8e16_v_u16m1x8(rs1, vs3, vl); } -void test_vsseg8e16_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, +void test_vsseg8e16_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsseg8e16_v_f16mf4x8_m(vm, rs1, vs3, vl); } -void test_vsseg8e16_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, +void test_vsseg8e16_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsseg8e16_v_f16mf2x8_m(vm, rs1, vs3, vl); } -void test_vsseg8e16_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, - vfloat16m1x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x8_t vs3, + size_t vl) { return __riscv_vsseg8e16_v_f16m1x8_m(vm, rs1, vs3, vl); } diff --git a/auto-generated/api-testing/vssseg2e16.c b/auto-generated/api-testing/vssseg2e16.c index cd2c3d395..503a854b7 100644 --- a/auto-generated/api-testing/vssseg2e16.c +++ b/auto-generated/api-testing/vssseg2e16.c @@ -5,28 +5,28 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg2e16_v_f16mf4x2(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg2e16_v_f16mf4x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16mf4x2(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16mf2x2(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg2e16_v_f16mf2x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16mf2x2(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m1x2(float16_t *rs1, ptrdiff_t rs2, - vfloat16m1x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m1x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x2_t vs3, + size_t vl) { return __riscv_vssseg2e16_v_f16m1x2(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m2x2(float16_t *rs1, ptrdiff_t rs2, - vfloat16m2x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m2x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16m2x2_t vs3, + size_t vl) { return __riscv_vssseg2e16_v_f16m2x2(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m4x2(float16_t *rs1, ptrdiff_t rs2, - vfloat16m4x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m4x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16m4x2_t vs3, + size_t vl) { return __riscv_vssseg2e16_v_f16m4x2(rs1, rs2, vs3, vl); } @@ -80,27 +80,27 @@ void test_vssseg2e16_v_u16m4x2(uint16_t *rs1, ptrdiff_t rs2, vuint16m4x2_t vs3, return __riscv_vssseg2e16_v_u16m4x2(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg2e16_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16mf4x2_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg2e16_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16mf2x2_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg2e16_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16m1x2_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg2e16_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16m2x2_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg2e16_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16m4x2_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/api-testing/vssseg3e16.c b/auto-generated/api-testing/vssseg3e16.c index 55257f983..495726849 100644 --- a/auto-generated/api-testing/vssseg3e16.c +++ b/auto-generated/api-testing/vssseg3e16.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg3e16_v_f16mf4x3(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg3e16_v_f16mf4x3(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vssseg3e16_v_f16mf4x3(rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16mf2x3(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg3e16_v_f16mf2x3(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vssseg3e16_v_f16mf2x3(rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16m1x3(float16_t *rs1, ptrdiff_t rs2, - vfloat16m1x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16m1x3(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x3_t vs3, + size_t vl) { return __riscv_vssseg3e16_v_f16m1x3(rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16m2x3(float16_t *rs1, ptrdiff_t rs2, - vfloat16m2x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16m2x3(_Float16 *rs1, ptrdiff_t rs2, vfloat16m2x3_t vs3, + size_t vl) { return __riscv_vssseg3e16_v_f16m2x3(rs1, rs2, vs3, vl); } @@ -65,22 +65,22 @@ void test_vssseg3e16_v_u16m2x3(uint16_t *rs1, ptrdiff_t rs2, vuint16m2x3_t vs3, return __riscv_vssseg3e16_v_u16m2x3(rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg3e16_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vssseg3e16_v_f16mf4x3_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg3e16_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vssseg3e16_v_f16mf2x3_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg3e16_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vssseg3e16_v_f16m1x3_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg3e16_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vssseg3e16_v_f16m2x3_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/api-testing/vssseg4e16.c b/auto-generated/api-testing/vssseg4e16.c index 43ee2525e..4af63efa0 100644 --- a/auto-generated/api-testing/vssseg4e16.c +++ b/auto-generated/api-testing/vssseg4e16.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg4e16_v_f16mf4x4(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg4e16_v_f16mf4x4(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vssseg4e16_v_f16mf4x4(rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16mf2x4(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg4e16_v_f16mf2x4(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vssseg4e16_v_f16mf2x4(rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16m1x4(float16_t *rs1, ptrdiff_t rs2, - vfloat16m1x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16m1x4(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x4_t vs3, + size_t vl) { return __riscv_vssseg4e16_v_f16m1x4(rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16m2x4(float16_t *rs1, ptrdiff_t rs2, - vfloat16m2x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16m2x4(_Float16 *rs1, ptrdiff_t rs2, vfloat16m2x4_t vs3, + size_t vl) { return __riscv_vssseg4e16_v_f16m2x4(rs1, rs2, vs3, vl); } @@ -65,22 +65,22 @@ void test_vssseg4e16_v_u16m2x4(uint16_t *rs1, ptrdiff_t rs2, vuint16m2x4_t vs3, return __riscv_vssseg4e16_v_u16m2x4(rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg4e16_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vssseg4e16_v_f16mf4x4_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg4e16_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vssseg4e16_v_f16mf2x4_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg4e16_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vssseg4e16_v_f16m1x4_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg4e16_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vssseg4e16_v_f16m2x4_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/api-testing/vssseg5e16.c b/auto-generated/api-testing/vssseg5e16.c index e10798bc2..7c0824056 100644 --- a/auto-generated/api-testing/vssseg5e16.c +++ b/auto-generated/api-testing/vssseg5e16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg5e16_v_f16mf4x5(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg5e16_v_f16mf4x5(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vssseg5e16_v_f16mf4x5(rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16mf2x5(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg5e16_v_f16mf2x5(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vssseg5e16_v_f16mf2x5(rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16m1x5(float16_t *rs1, ptrdiff_t rs2, - vfloat16m1x5_t vs3, size_t vl) { +void test_vssseg5e16_v_f16m1x5(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x5_t vs3, + size_t vl) { return __riscv_vssseg5e16_v_f16m1x5(rs1, rs2, vs3, vl); } @@ -50,17 +50,17 @@ void test_vssseg5e16_v_u16m1x5(uint16_t *rs1, ptrdiff_t rs2, vuint16m1x5_t vs3, return __riscv_vssseg5e16_v_u16m1x5(rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg5e16_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vssseg5e16_v_f16mf4x5_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg5e16_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vssseg5e16_v_f16mf2x5_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg5e16_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vssseg5e16_v_f16m1x5_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/api-testing/vssseg6e16.c b/auto-generated/api-testing/vssseg6e16.c index e16dd7264..96f33ef4d 100644 --- a/auto-generated/api-testing/vssseg6e16.c +++ b/auto-generated/api-testing/vssseg6e16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg6e16_v_f16mf4x6(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg6e16_v_f16mf4x6(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vssseg6e16_v_f16mf4x6(rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16mf2x6(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg6e16_v_f16mf2x6(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vssseg6e16_v_f16mf2x6(rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16m1x6(float16_t *rs1, ptrdiff_t rs2, - vfloat16m1x6_t vs3, size_t vl) { +void test_vssseg6e16_v_f16m1x6(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x6_t vs3, + size_t vl) { return __riscv_vssseg6e16_v_f16m1x6(rs1, rs2, vs3, vl); } @@ -50,17 +50,17 @@ void test_vssseg6e16_v_u16m1x6(uint16_t *rs1, ptrdiff_t rs2, vuint16m1x6_t vs3, return __riscv_vssseg6e16_v_u16m1x6(rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg6e16_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vssseg6e16_v_f16mf4x6_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg6e16_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vssseg6e16_v_f16mf2x6_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg6e16_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vssseg6e16_v_f16m1x6_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/api-testing/vssseg7e16.c b/auto-generated/api-testing/vssseg7e16.c index 847aebe10..ae6782f5b 100644 --- a/auto-generated/api-testing/vssseg7e16.c +++ b/auto-generated/api-testing/vssseg7e16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg7e16_v_f16mf4x7(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg7e16_v_f16mf4x7(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vssseg7e16_v_f16mf4x7(rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16mf2x7(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg7e16_v_f16mf2x7(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vssseg7e16_v_f16mf2x7(rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16m1x7(float16_t *rs1, ptrdiff_t rs2, - vfloat16m1x7_t vs3, size_t vl) { +void test_vssseg7e16_v_f16m1x7(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x7_t vs3, + size_t vl) { return __riscv_vssseg7e16_v_f16m1x7(rs1, rs2, vs3, vl); } @@ -50,17 +50,17 @@ void test_vssseg7e16_v_u16m1x7(uint16_t *rs1, ptrdiff_t rs2, vuint16m1x7_t vs3, return __riscv_vssseg7e16_v_u16m1x7(rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg7e16_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vssseg7e16_v_f16mf4x7_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg7e16_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vssseg7e16_v_f16mf2x7_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg7e16_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vssseg7e16_v_f16m1x7_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/api-testing/vssseg8e16.c b/auto-generated/api-testing/vssseg8e16.c index 479a9f139..301d2f8aa 100644 --- a/auto-generated/api-testing/vssseg8e16.c +++ b/auto-generated/api-testing/vssseg8e16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg8e16_v_f16mf4x8(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg8e16_v_f16mf4x8(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vssseg8e16_v_f16mf4x8(rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16mf2x8(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg8e16_v_f16mf2x8(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vssseg8e16_v_f16mf2x8(rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16m1x8(float16_t *rs1, ptrdiff_t rs2, - vfloat16m1x8_t vs3, size_t vl) { +void test_vssseg8e16_v_f16m1x8(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x8_t vs3, + size_t vl) { return __riscv_vssseg8e16_v_f16m1x8(rs1, rs2, vs3, vl); } @@ -50,17 +50,17 @@ void test_vssseg8e16_v_u16m1x8(uint16_t *rs1, ptrdiff_t rs2, vuint16m1x8_t vs3, return __riscv_vssseg8e16_v_u16m1x8(rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg8e16_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vssseg8e16_v_f16mf4x8_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg8e16_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vssseg8e16_v_f16mf2x8_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg8e16_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vssseg8e16_v_f16m1x8_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxei16.c b/auto-generated/api-testing/vsuxei16.c index 8009d5310..8c9c27363 100644 --- a/auto-generated/api-testing/vsuxei16.c +++ b/auto-generated/api-testing/vsuxei16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxei16_v_f16mf4(float16_t *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, +void test_vsuxei16_v_f16mf4(_Float16 *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16mf2(float16_t *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, +void test_vsuxei16_v_f16mf2(_Float16 *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m1(float16_t *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, +void test_vsuxei16_v_f16m1(_Float16 *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m2(float16_t *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, +void test_vsuxei16_v_f16m2(_Float16 *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16m2(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m4(float16_t *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, +void test_vsuxei16_v_f16m4(_Float16 *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16m4(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m8(float16_t *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, +void test_vsuxei16_v_f16m8(_Float16 *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16m8(rs1, rs2, vs3, vl); } @@ -290,32 +290,32 @@ void test_vsuxei16_v_u64m8(uint64_t *rs1, vuint16m2_t rs2, vuint64m8_t vs3, return __riscv_vsuxei16_v_u64m8(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t rs2, +void test_vsuxei16_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t rs2, +void test_vsuxei16_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint16m1_t rs2, +void test_vsuxei16_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint16m2_t rs2, +void test_vsuxei16_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16m2_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint16m4_t rs2, +void test_vsuxei16_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16m4_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m8_m(vbool2_t vm, float16_t *rs1, vuint16m8_t rs2, +void test_vsuxei16_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16m8_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxei32.c b/auto-generated/api-testing/vsuxei32.c index becc7b354..0ac1412a4 100644 --- a/auto-generated/api-testing/vsuxei32.c +++ b/auto-generated/api-testing/vsuxei32.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxei32_v_f16mf4(float16_t *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, +void test_vsuxei32_v_f16mf4(_Float16 *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16mf2(float16_t *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, +void test_vsuxei32_v_f16mf2(_Float16 *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m1(float16_t *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, +void test_vsuxei32_v_f16m1(_Float16 *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m2(float16_t *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, +void test_vsuxei32_v_f16m2(_Float16 *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16m2(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m4(float16_t *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, +void test_vsuxei32_v_f16m4(_Float16 *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16m4(rs1, rs2, vs3, vl); } @@ -265,27 +265,27 @@ void test_vsuxei32_v_u64m8(uint64_t *rs1, vuint32m4_t rs2, vuint64m8_t vs3, return __riscv_vsuxei32_v_u64m8(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t rs2, +void test_vsuxei32_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint32m1_t rs2, +void test_vsuxei32_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint32m2_t rs2, +void test_vsuxei32_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint32m4_t rs2, +void test_vsuxei32_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16m2_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint32m8_t rs2, +void test_vsuxei32_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16m4_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxei64.c b/auto-generated/api-testing/vsuxei64.c index e2f102361..1deb9f842 100644 --- a/auto-generated/api-testing/vsuxei64.c +++ b/auto-generated/api-testing/vsuxei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxei64_v_f16mf4(float16_t *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, +void test_vsuxei64_v_f16mf4(_Float16 *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei64_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16mf2(float16_t *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, +void test_vsuxei64_v_f16mf2(_Float16 *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei64_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16m1(float16_t *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, +void test_vsuxei64_v_f16m1(_Float16 *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei64_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16m2(float16_t *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, +void test_vsuxei64_v_f16m2(_Float16 *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei64_v_f16m2(rs1, rs2, vs3, vl); } @@ -225,22 +225,22 @@ void test_vsuxei64_v_u64m8(uint64_t *rs1, vuint64m8_t rs2, vuint64m8_t vs3, return __riscv_vsuxei64_v_u64m8(rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint64m1_t rs2, +void test_vsuxei64_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei64_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint64m2_t rs2, +void test_vsuxei64_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei64_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint64m4_t rs2, +void test_vsuxei64_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei64_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint64m8_t rs2, +void test_vsuxei64_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei64_v_f16m2_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxei8.c b/auto-generated/api-testing/vsuxei8.c index 8e0b409ae..3225a0ef1 100644 --- a/auto-generated/api-testing/vsuxei8.c +++ b/auto-generated/api-testing/vsuxei8.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxei8_v_f16mf4(float16_t *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, +void test_vsuxei8_v_f16mf4(_Float16 *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16mf2(float16_t *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, +void test_vsuxei8_v_f16mf2(_Float16 *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m1(float16_t *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, +void test_vsuxei8_v_f16m1(_Float16 *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m2(float16_t *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, +void test_vsuxei8_v_f16m2(_Float16 *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16m2(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m4(float16_t *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, +void test_vsuxei8_v_f16m4(_Float16 *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16m4(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m8(float16_t *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, +void test_vsuxei8_v_f16m8(_Float16 *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16m8(rs1, rs2, vs3, vl); } @@ -300,32 +300,32 @@ void test_vsuxei8_v_u64m8(uint64_t *rs1, vuint8m1_t rs2, vuint64m8_t vs3, return __riscv_vsuxei8_v_u64m8(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t rs2, +void test_vsuxei8_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t rs2, +void test_vsuxei8_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t rs2, +void test_vsuxei8_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint8m1_t rs2, +void test_vsuxei8_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16m2_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint8m2_t rs2, +void test_vsuxei8_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16m4_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m8_m(vbool2_t vm, float16_t *rs1, vuint8m4_t rs2, +void test_vsuxei8_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16m8_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg2ei16.c b/auto-generated/api-testing/vsuxseg2ei16.c index 55d3f5bc3..bd29828c0 100644 --- a/auto-generated/api-testing/vsuxseg2ei16.c +++ b/auto-generated/api-testing/vsuxseg2ei16.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg2ei16_v_f16mf4x2(float16_t *rs1, vuint16mf4_t vs2, +void test_vsuxseg2ei16_v_f16mf4x2(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16mf4x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16mf2x2(float16_t *rs1, vuint16mf2_t vs2, +void test_vsuxseg2ei16_v_f16mf2x2(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16mf2x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m1x2(float16_t *rs1, vuint16m1_t vs2, +void test_vsuxseg2ei16_v_f16m1x2(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16m1x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m2x2(float16_t *rs1, vuint16m2_t vs2, +void test_vsuxseg2ei16_v_f16m2x2(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16m2x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m4x2(float16_t *rs1, vuint16m4_t vs2, +void test_vsuxseg2ei16_v_f16m4x2(_Float16 *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16m4x2(rs1, vs2, vs3, vl); } @@ -245,30 +245,29 @@ void test_vsuxseg2ei16_v_u64m4x2(uint64_t *rs1, vuint16m1_t vs2, return __riscv_vsuxseg2ei16_v_u64m4x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg2ei16_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16mf4x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg2ei16_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16mf2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x2_t vs3, - size_t vl) { +void test_vsuxseg2ei16_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16m1x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, +void test_vsuxseg2ei16_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16m2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint16m4_t vs2, +void test_vsuxseg2ei16_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16m4x2_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg2ei32.c b/auto-generated/api-testing/vsuxseg2ei32.c index 2f3bffa06..43dd04b91 100644 --- a/auto-generated/api-testing/vsuxseg2ei32.c +++ b/auto-generated/api-testing/vsuxseg2ei32.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg2ei32_v_f16mf4x2(float16_t *rs1, vuint32mf2_t vs2, +void test_vsuxseg2ei32_v_f16mf4x2(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16mf4x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16mf2x2(float16_t *rs1, vuint32m1_t vs2, +void test_vsuxseg2ei32_v_f16mf2x2(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16mf2x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m1x2(float16_t *rs1, vuint32m2_t vs2, +void test_vsuxseg2ei32_v_f16m1x2(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16m1x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m2x2(float16_t *rs1, vuint32m4_t vs2, +void test_vsuxseg2ei32_v_f16m2x2(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16m2x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m4x2(float16_t *rs1, vuint32m8_t vs2, +void test_vsuxseg2ei32_v_f16m4x2(_Float16 *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16m4x2(rs1, vs2, vs3, vl); } @@ -235,30 +235,29 @@ void test_vsuxseg2ei32_v_u64m4x2(uint64_t *rs1, vuint32m2_t vs2, return __riscv_vsuxseg2ei32_v_u64m4x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg2ei32_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16mf4x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg2ei32_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16mf2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x2_t vs3, - size_t vl) { +void test_vsuxseg2ei32_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16m1x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, +void test_vsuxseg2ei32_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16m2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint32m8_t vs2, +void test_vsuxseg2ei32_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16m4x2_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg2ei64.c b/auto-generated/api-testing/vsuxseg2ei64.c index 24feb4d27..87b875a8c 100644 --- a/auto-generated/api-testing/vsuxseg2ei64.c +++ b/auto-generated/api-testing/vsuxseg2ei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg2ei64_v_f16mf4x2(float16_t *rs1, vuint64m1_t vs2, +void test_vsuxseg2ei64_v_f16mf4x2(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64_v_f16mf4x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16mf2x2(float16_t *rs1, vuint64m2_t vs2, +void test_vsuxseg2ei64_v_f16mf2x2(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64_v_f16mf2x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16m1x2(float16_t *rs1, vuint64m4_t vs2, +void test_vsuxseg2ei64_v_f16m1x2(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64_v_f16m1x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16m2x2(float16_t *rs1, vuint64m8_t vs2, +void test_vsuxseg2ei64_v_f16m2x2(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64_v_f16m2x2(rs1, vs2, vs3, vl); } @@ -210,25 +210,24 @@ void test_vsuxseg2ei64_v_u64m4x2(uint64_t *rs1, vuint64m4_t vs2, return __riscv_vsuxseg2ei64_v_u64m4x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg2ei64_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64_v_f16mf4x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg2ei64_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64_v_f16mf2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x2_t vs3, - size_t vl) { +void test_vsuxseg2ei64_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64_v_f16m1x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, +void test_vsuxseg2ei64_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64_v_f16m2x2_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg2ei8.c b/auto-generated/api-testing/vsuxseg2ei8.c index 78698390b..48ac15102 100644 --- a/auto-generated/api-testing/vsuxseg2ei8.c +++ b/auto-generated/api-testing/vsuxseg2ei8.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg2ei8_v_f16mf4x2(float16_t *rs1, vuint8mf8_t vs2, +void test_vsuxseg2ei8_v_f16mf4x2(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16mf4x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16mf2x2(float16_t *rs1, vuint8mf4_t vs2, +void test_vsuxseg2ei8_v_f16mf2x2(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16mf2x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m1x2(float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg2ei8_v_f16m1x2(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16m1x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m2x2(float16_t *rs1, vuint8m1_t vs2, +void test_vsuxseg2ei8_v_f16m2x2(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16m2x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m4x2(float16_t *rs1, vuint8m2_t vs2, +void test_vsuxseg2ei8_v_f16m4x2(_Float16 *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16m4x2(rs1, vs2, vs3, vl); } @@ -245,29 +245,27 @@ void test_vsuxseg2ei8_v_u64m4x2(uint64_t *rs1, vuint8mf2_t vs2, return __riscv_vsuxseg2ei8_v_u64m4x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x2_t vs3, - size_t vl) { +void test_vsuxseg2ei8_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16mf4x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x2_t vs3, - size_t vl) { +void test_vsuxseg2ei8_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16mf2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg2ei8_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16m1x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, +void test_vsuxseg2ei8_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16m2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint8m2_t vs2, +void test_vsuxseg2ei8_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16m4x2_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg3ei16.c b/auto-generated/api-testing/vsuxseg3ei16.c index 3c30f63de..8341e2561 100644 --- a/auto-generated/api-testing/vsuxseg3ei16.c +++ b/auto-generated/api-testing/vsuxseg3ei16.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg3ei16_v_f16mf4x3(float16_t *rs1, vuint16mf4_t vs2, +void test_vsuxseg3ei16_v_f16mf4x3(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16_v_f16mf4x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16mf2x3(float16_t *rs1, vuint16mf2_t vs2, +void test_vsuxseg3ei16_v_f16mf2x3(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16_v_f16mf2x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16m1x3(float16_t *rs1, vuint16m1_t vs2, +void test_vsuxseg3ei16_v_f16m1x3(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16_v_f16m1x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16m2x3(float16_t *rs1, vuint16m2_t vs2, +void test_vsuxseg3ei16_v_f16m2x3(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16_v_f16m2x3(rs1, vs2, vs3, vl); } @@ -190,25 +190,24 @@ void test_vsuxseg3ei16_v_u64m2x3(uint64_t *rs1, vuint16mf2_t vs2, return __riscv_vsuxseg3ei16_v_u64m2x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg3ei16_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16_v_f16mf4x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg3ei16_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16_v_f16mf2x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x3_t vs3, - size_t vl) { +void test_vsuxseg3ei16_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16_v_f16m1x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, +void test_vsuxseg3ei16_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16_v_f16m2x3_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg3ei32.c b/auto-generated/api-testing/vsuxseg3ei32.c index 0cc7e211e..966b1c987 100644 --- a/auto-generated/api-testing/vsuxseg3ei32.c +++ b/auto-generated/api-testing/vsuxseg3ei32.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg3ei32_v_f16mf4x3(float16_t *rs1, vuint32mf2_t vs2, +void test_vsuxseg3ei32_v_f16mf4x3(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32_v_f16mf4x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16mf2x3(float16_t *rs1, vuint32m1_t vs2, +void test_vsuxseg3ei32_v_f16mf2x3(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32_v_f16mf2x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16m1x3(float16_t *rs1, vuint32m2_t vs2, +void test_vsuxseg3ei32_v_f16m1x3(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32_v_f16m1x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16m2x3(float16_t *rs1, vuint32m4_t vs2, +void test_vsuxseg3ei32_v_f16m2x3(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32_v_f16m2x3(rs1, vs2, vs3, vl); } @@ -190,25 +190,24 @@ void test_vsuxseg3ei32_v_u64m2x3(uint64_t *rs1, vuint32m1_t vs2, return __riscv_vsuxseg3ei32_v_u64m2x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg3ei32_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32_v_f16mf4x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg3ei32_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32_v_f16mf2x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x3_t vs3, - size_t vl) { +void test_vsuxseg3ei32_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32_v_f16m1x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, +void test_vsuxseg3ei32_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32_v_f16m2x3_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg3ei64.c b/auto-generated/api-testing/vsuxseg3ei64.c index eab6db297..82c72cd22 100644 --- a/auto-generated/api-testing/vsuxseg3ei64.c +++ b/auto-generated/api-testing/vsuxseg3ei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg3ei64_v_f16mf4x3(float16_t *rs1, vuint64m1_t vs2, +void test_vsuxseg3ei64_v_f16mf4x3(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64_v_f16mf4x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16mf2x3(float16_t *rs1, vuint64m2_t vs2, +void test_vsuxseg3ei64_v_f16mf2x3(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64_v_f16mf2x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16m1x3(float16_t *rs1, vuint64m4_t vs2, +void test_vsuxseg3ei64_v_f16m1x3(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64_v_f16m1x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16m2x3(float16_t *rs1, vuint64m8_t vs2, +void test_vsuxseg3ei64_v_f16m2x3(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64_v_f16m2x3(rs1, vs2, vs3, vl); } @@ -180,25 +180,24 @@ void test_vsuxseg3ei64_v_u64m2x3(uint64_t *rs1, vuint64m2_t vs2, return __riscv_vsuxseg3ei64_v_u64m2x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg3ei64_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64_v_f16mf4x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg3ei64_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64_v_f16mf2x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x3_t vs3, - size_t vl) { +void test_vsuxseg3ei64_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64_v_f16m1x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, +void test_vsuxseg3ei64_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64_v_f16m2x3_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg3ei8.c b/auto-generated/api-testing/vsuxseg3ei8.c index 74ff47b1b..e5e973352 100644 --- a/auto-generated/api-testing/vsuxseg3ei8.c +++ b/auto-generated/api-testing/vsuxseg3ei8.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg3ei8_v_f16mf4x3(float16_t *rs1, vuint8mf8_t vs2, +void test_vsuxseg3ei8_v_f16mf4x3(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8_v_f16mf4x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16mf2x3(float16_t *rs1, vuint8mf4_t vs2, +void test_vsuxseg3ei8_v_f16mf2x3(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8_v_f16mf2x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16m1x3(float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg3ei8_v_f16m1x3(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8_v_f16m1x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16m2x3(float16_t *rs1, vuint8m1_t vs2, +void test_vsuxseg3ei8_v_f16m2x3(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8_v_f16m2x3(rs1, vs2, vs3, vl); } @@ -190,24 +190,22 @@ void test_vsuxseg3ei8_v_u64m2x3(uint64_t *rs1, vuint8mf4_t vs2, return __riscv_vsuxseg3ei8_v_u64m2x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x3_t vs3, - size_t vl) { +void test_vsuxseg3ei8_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8_v_f16mf4x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x3_t vs3, - size_t vl) { +void test_vsuxseg3ei8_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8_v_f16mf2x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg3ei8_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8_v_f16m1x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, +void test_vsuxseg3ei8_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8_v_f16m2x3_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg4ei16.c b/auto-generated/api-testing/vsuxseg4ei16.c index f64d5e5e3..ba3b65eb0 100644 --- a/auto-generated/api-testing/vsuxseg4ei16.c +++ b/auto-generated/api-testing/vsuxseg4ei16.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg4ei16_v_f16mf4x4(float16_t *rs1, vuint16mf4_t vs2, +void test_vsuxseg4ei16_v_f16mf4x4(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16_v_f16mf4x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16mf2x4(float16_t *rs1, vuint16mf2_t vs2, +void test_vsuxseg4ei16_v_f16mf2x4(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16_v_f16mf2x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16m1x4(float16_t *rs1, vuint16m1_t vs2, +void test_vsuxseg4ei16_v_f16m1x4(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16_v_f16m1x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16m2x4(float16_t *rs1, vuint16m2_t vs2, +void test_vsuxseg4ei16_v_f16m2x4(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16_v_f16m2x4(rs1, vs2, vs3, vl); } @@ -190,25 +190,24 @@ void test_vsuxseg4ei16_v_u64m2x4(uint64_t *rs1, vuint16mf2_t vs2, return __riscv_vsuxseg4ei16_v_u64m2x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg4ei16_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16_v_f16mf4x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg4ei16_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16_v_f16mf2x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x4_t vs3, - size_t vl) { +void test_vsuxseg4ei16_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16_v_f16m1x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, +void test_vsuxseg4ei16_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16_v_f16m2x4_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg4ei32.c b/auto-generated/api-testing/vsuxseg4ei32.c index 81c70f13d..195507d90 100644 --- a/auto-generated/api-testing/vsuxseg4ei32.c +++ b/auto-generated/api-testing/vsuxseg4ei32.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg4ei32_v_f16mf4x4(float16_t *rs1, vuint32mf2_t vs2, +void test_vsuxseg4ei32_v_f16mf4x4(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32_v_f16mf4x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16mf2x4(float16_t *rs1, vuint32m1_t vs2, +void test_vsuxseg4ei32_v_f16mf2x4(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32_v_f16mf2x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16m1x4(float16_t *rs1, vuint32m2_t vs2, +void test_vsuxseg4ei32_v_f16m1x4(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32_v_f16m1x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16m2x4(float16_t *rs1, vuint32m4_t vs2, +void test_vsuxseg4ei32_v_f16m2x4(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32_v_f16m2x4(rs1, vs2, vs3, vl); } @@ -190,25 +190,24 @@ void test_vsuxseg4ei32_v_u64m2x4(uint64_t *rs1, vuint32m1_t vs2, return __riscv_vsuxseg4ei32_v_u64m2x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg4ei32_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32_v_f16mf4x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg4ei32_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32_v_f16mf2x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x4_t vs3, - size_t vl) { +void test_vsuxseg4ei32_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32_v_f16m1x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, +void test_vsuxseg4ei32_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32_v_f16m2x4_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg4ei64.c b/auto-generated/api-testing/vsuxseg4ei64.c index df434c7e0..a816470ae 100644 --- a/auto-generated/api-testing/vsuxseg4ei64.c +++ b/auto-generated/api-testing/vsuxseg4ei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg4ei64_v_f16mf4x4(float16_t *rs1, vuint64m1_t vs2, +void test_vsuxseg4ei64_v_f16mf4x4(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64_v_f16mf4x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16mf2x4(float16_t *rs1, vuint64m2_t vs2, +void test_vsuxseg4ei64_v_f16mf2x4(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64_v_f16mf2x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16m1x4(float16_t *rs1, vuint64m4_t vs2, +void test_vsuxseg4ei64_v_f16m1x4(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64_v_f16m1x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16m2x4(float16_t *rs1, vuint64m8_t vs2, +void test_vsuxseg4ei64_v_f16m2x4(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64_v_f16m2x4(rs1, vs2, vs3, vl); } @@ -180,25 +180,24 @@ void test_vsuxseg4ei64_v_u64m2x4(uint64_t *rs1, vuint64m2_t vs2, return __riscv_vsuxseg4ei64_v_u64m2x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg4ei64_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64_v_f16mf4x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg4ei64_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64_v_f16mf2x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x4_t vs3, - size_t vl) { +void test_vsuxseg4ei64_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64_v_f16m1x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, +void test_vsuxseg4ei64_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64_v_f16m2x4_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg4ei8.c b/auto-generated/api-testing/vsuxseg4ei8.c index dda88ff0a..a3a3c99ff 100644 --- a/auto-generated/api-testing/vsuxseg4ei8.c +++ b/auto-generated/api-testing/vsuxseg4ei8.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg4ei8_v_f16mf4x4(float16_t *rs1, vuint8mf8_t vs2, +void test_vsuxseg4ei8_v_f16mf4x4(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8_v_f16mf4x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16mf2x4(float16_t *rs1, vuint8mf4_t vs2, +void test_vsuxseg4ei8_v_f16mf2x4(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8_v_f16mf2x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16m1x4(float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg4ei8_v_f16m1x4(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8_v_f16m1x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16m2x4(float16_t *rs1, vuint8m1_t vs2, +void test_vsuxseg4ei8_v_f16m2x4(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8_v_f16m2x4(rs1, vs2, vs3, vl); } @@ -190,24 +190,22 @@ void test_vsuxseg4ei8_v_u64m2x4(uint64_t *rs1, vuint8mf4_t vs2, return __riscv_vsuxseg4ei8_v_u64m2x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x4_t vs3, - size_t vl) { +void test_vsuxseg4ei8_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8_v_f16mf4x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x4_t vs3, - size_t vl) { +void test_vsuxseg4ei8_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8_v_f16mf2x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg4ei8_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8_v_f16m1x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, +void test_vsuxseg4ei8_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8_v_f16m2x4_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg5ei16.c b/auto-generated/api-testing/vsuxseg5ei16.c index c83a961cc..d7cc92cbd 100644 --- a/auto-generated/api-testing/vsuxseg5ei16.c +++ b/auto-generated/api-testing/vsuxseg5ei16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg5ei16_v_f16mf4x5(float16_t *rs1, vuint16mf4_t vs2, +void test_vsuxseg5ei16_v_f16mf4x5(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16_v_f16mf4x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16mf2x5(float16_t *rs1, vuint16mf2_t vs2, +void test_vsuxseg5ei16_v_f16mf2x5(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16_v_f16mf2x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16m1x5(float16_t *rs1, vuint16m1_t vs2, +void test_vsuxseg5ei16_v_f16m1x5(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16_v_f16m1x5(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg5ei16_v_u64m1x5(uint64_t *rs1, vuint16mf4_t vs2, return __riscv_vsuxseg5ei16_v_u64m1x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg5ei16_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16_v_f16mf4x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg5ei16_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16_v_f16mf2x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x5_t vs3, - size_t vl) { +void test_vsuxseg5ei16_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16_v_f16m1x5_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg5ei32.c b/auto-generated/api-testing/vsuxseg5ei32.c index 85c02db58..e3aa3369b 100644 --- a/auto-generated/api-testing/vsuxseg5ei32.c +++ b/auto-generated/api-testing/vsuxseg5ei32.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg5ei32_v_f16mf4x5(float16_t *rs1, vuint32mf2_t vs2, +void test_vsuxseg5ei32_v_f16mf4x5(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32_v_f16mf4x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16mf2x5(float16_t *rs1, vuint32m1_t vs2, +void test_vsuxseg5ei32_v_f16mf2x5(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32_v_f16mf2x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16m1x5(float16_t *rs1, vuint32m2_t vs2, +void test_vsuxseg5ei32_v_f16m1x5(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32_v_f16m1x5(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg5ei32_v_u64m1x5(uint64_t *rs1, vuint32mf2_t vs2, return __riscv_vsuxseg5ei32_v_u64m1x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg5ei32_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32_v_f16mf4x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg5ei32_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32_v_f16mf2x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x5_t vs3, - size_t vl) { +void test_vsuxseg5ei32_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32_v_f16m1x5_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg5ei64.c b/auto-generated/api-testing/vsuxseg5ei64.c index cd66dfdc2..bfb959685 100644 --- a/auto-generated/api-testing/vsuxseg5ei64.c +++ b/auto-generated/api-testing/vsuxseg5ei64.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg5ei64_v_f16mf4x5(float16_t *rs1, vuint64m1_t vs2, +void test_vsuxseg5ei64_v_f16mf4x5(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64_v_f16mf4x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16mf2x5(float16_t *rs1, vuint64m2_t vs2, +void test_vsuxseg5ei64_v_f16mf2x5(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64_v_f16mf2x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16m1x5(float16_t *rs1, vuint64m4_t vs2, +void test_vsuxseg5ei64_v_f16m1x5(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64_v_f16m1x5(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg5ei64_v_u64m1x5(uint64_t *rs1, vuint64m1_t vs2, return __riscv_vsuxseg5ei64_v_u64m1x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg5ei64_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64_v_f16mf4x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg5ei64_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64_v_f16mf2x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x5_t vs3, - size_t vl) { +void test_vsuxseg5ei64_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64_v_f16m1x5_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg5ei8.c b/auto-generated/api-testing/vsuxseg5ei8.c index d9f319b4d..bfd1cab85 100644 --- a/auto-generated/api-testing/vsuxseg5ei8.c +++ b/auto-generated/api-testing/vsuxseg5ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg5ei8_v_f16mf4x5(float16_t *rs1, vuint8mf8_t vs2, +void test_vsuxseg5ei8_v_f16mf4x5(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8_v_f16mf4x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16mf2x5(float16_t *rs1, vuint8mf4_t vs2, +void test_vsuxseg5ei8_v_f16mf2x5(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8_v_f16mf2x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16m1x5(float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg5ei8_v_f16m1x5(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8_v_f16m1x5(rs1, vs2, vs3, vl); } @@ -135,19 +135,17 @@ void test_vsuxseg5ei8_v_u64m1x5(uint64_t *rs1, vuint8mf8_t vs2, return __riscv_vsuxseg5ei8_v_u64m1x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x5_t vs3, - size_t vl) { +void test_vsuxseg5ei8_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8_v_f16mf4x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x5_t vs3, - size_t vl) { +void test_vsuxseg5ei8_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8_v_f16mf2x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg5ei8_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8_v_f16m1x5_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg6ei16.c b/auto-generated/api-testing/vsuxseg6ei16.c index a925a56f6..cfff4bdd7 100644 --- a/auto-generated/api-testing/vsuxseg6ei16.c +++ b/auto-generated/api-testing/vsuxseg6ei16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg6ei16_v_f16mf4x6(float16_t *rs1, vuint16mf4_t vs2, +void test_vsuxseg6ei16_v_f16mf4x6(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16_v_f16mf4x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16mf2x6(float16_t *rs1, vuint16mf2_t vs2, +void test_vsuxseg6ei16_v_f16mf2x6(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16_v_f16mf2x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16m1x6(float16_t *rs1, vuint16m1_t vs2, +void test_vsuxseg6ei16_v_f16m1x6(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16_v_f16m1x6(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg6ei16_v_u64m1x6(uint64_t *rs1, vuint16mf4_t vs2, return __riscv_vsuxseg6ei16_v_u64m1x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg6ei16_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16_v_f16mf4x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg6ei16_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16_v_f16mf2x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x6_t vs3, - size_t vl) { +void test_vsuxseg6ei16_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16_v_f16m1x6_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg6ei32.c b/auto-generated/api-testing/vsuxseg6ei32.c index 397504001..82cd10d14 100644 --- a/auto-generated/api-testing/vsuxseg6ei32.c +++ b/auto-generated/api-testing/vsuxseg6ei32.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg6ei32_v_f16mf4x6(float16_t *rs1, vuint32mf2_t vs2, +void test_vsuxseg6ei32_v_f16mf4x6(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32_v_f16mf4x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16mf2x6(float16_t *rs1, vuint32m1_t vs2, +void test_vsuxseg6ei32_v_f16mf2x6(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32_v_f16mf2x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16m1x6(float16_t *rs1, vuint32m2_t vs2, +void test_vsuxseg6ei32_v_f16m1x6(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32_v_f16m1x6(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg6ei32_v_u64m1x6(uint64_t *rs1, vuint32mf2_t vs2, return __riscv_vsuxseg6ei32_v_u64m1x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg6ei32_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32_v_f16mf4x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg6ei32_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32_v_f16mf2x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x6_t vs3, - size_t vl) { +void test_vsuxseg6ei32_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32_v_f16m1x6_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg6ei64.c b/auto-generated/api-testing/vsuxseg6ei64.c index c665de65c..40fc62cf4 100644 --- a/auto-generated/api-testing/vsuxseg6ei64.c +++ b/auto-generated/api-testing/vsuxseg6ei64.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg6ei64_v_f16mf4x6(float16_t *rs1, vuint64m1_t vs2, +void test_vsuxseg6ei64_v_f16mf4x6(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64_v_f16mf4x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16mf2x6(float16_t *rs1, vuint64m2_t vs2, +void test_vsuxseg6ei64_v_f16mf2x6(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64_v_f16mf2x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16m1x6(float16_t *rs1, vuint64m4_t vs2, +void test_vsuxseg6ei64_v_f16m1x6(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64_v_f16m1x6(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg6ei64_v_u64m1x6(uint64_t *rs1, vuint64m1_t vs2, return __riscv_vsuxseg6ei64_v_u64m1x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg6ei64_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64_v_f16mf4x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg6ei64_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64_v_f16mf2x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x6_t vs3, - size_t vl) { +void test_vsuxseg6ei64_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64_v_f16m1x6_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg6ei8.c b/auto-generated/api-testing/vsuxseg6ei8.c index e45bce7f1..63a5a004e 100644 --- a/auto-generated/api-testing/vsuxseg6ei8.c +++ b/auto-generated/api-testing/vsuxseg6ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg6ei8_v_f16mf4x6(float16_t *rs1, vuint8mf8_t vs2, +void test_vsuxseg6ei8_v_f16mf4x6(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8_v_f16mf4x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16mf2x6(float16_t *rs1, vuint8mf4_t vs2, +void test_vsuxseg6ei8_v_f16mf2x6(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8_v_f16mf2x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16m1x6(float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg6ei8_v_f16m1x6(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8_v_f16m1x6(rs1, vs2, vs3, vl); } @@ -135,19 +135,17 @@ void test_vsuxseg6ei8_v_u64m1x6(uint64_t *rs1, vuint8mf8_t vs2, return __riscv_vsuxseg6ei8_v_u64m1x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x6_t vs3, - size_t vl) { +void test_vsuxseg6ei8_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8_v_f16mf4x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x6_t vs3, - size_t vl) { +void test_vsuxseg6ei8_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8_v_f16mf2x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg6ei8_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8_v_f16m1x6_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg7ei16.c b/auto-generated/api-testing/vsuxseg7ei16.c index 725f966f8..8c68c4220 100644 --- a/auto-generated/api-testing/vsuxseg7ei16.c +++ b/auto-generated/api-testing/vsuxseg7ei16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg7ei16_v_f16mf4x7(float16_t *rs1, vuint16mf4_t vs2, +void test_vsuxseg7ei16_v_f16mf4x7(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16_v_f16mf4x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16mf2x7(float16_t *rs1, vuint16mf2_t vs2, +void test_vsuxseg7ei16_v_f16mf2x7(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16_v_f16mf2x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16m1x7(float16_t *rs1, vuint16m1_t vs2, +void test_vsuxseg7ei16_v_f16m1x7(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16_v_f16m1x7(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg7ei16_v_u64m1x7(uint64_t *rs1, vuint16mf4_t vs2, return __riscv_vsuxseg7ei16_v_u64m1x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg7ei16_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16_v_f16mf4x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg7ei16_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16_v_f16mf2x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x7_t vs3, - size_t vl) { +void test_vsuxseg7ei16_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16_v_f16m1x7_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg7ei32.c b/auto-generated/api-testing/vsuxseg7ei32.c index 9a809c731..665332c6c 100644 --- a/auto-generated/api-testing/vsuxseg7ei32.c +++ b/auto-generated/api-testing/vsuxseg7ei32.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg7ei32_v_f16mf4x7(float16_t *rs1, vuint32mf2_t vs2, +void test_vsuxseg7ei32_v_f16mf4x7(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32_v_f16mf4x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16mf2x7(float16_t *rs1, vuint32m1_t vs2, +void test_vsuxseg7ei32_v_f16mf2x7(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32_v_f16mf2x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16m1x7(float16_t *rs1, vuint32m2_t vs2, +void test_vsuxseg7ei32_v_f16m1x7(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32_v_f16m1x7(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg7ei32_v_u64m1x7(uint64_t *rs1, vuint32mf2_t vs2, return __riscv_vsuxseg7ei32_v_u64m1x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg7ei32_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32_v_f16mf4x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg7ei32_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32_v_f16mf2x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x7_t vs3, - size_t vl) { +void test_vsuxseg7ei32_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32_v_f16m1x7_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg7ei64.c b/auto-generated/api-testing/vsuxseg7ei64.c index a44110c8c..bd8a4e975 100644 --- a/auto-generated/api-testing/vsuxseg7ei64.c +++ b/auto-generated/api-testing/vsuxseg7ei64.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg7ei64_v_f16mf4x7(float16_t *rs1, vuint64m1_t vs2, +void test_vsuxseg7ei64_v_f16mf4x7(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64_v_f16mf4x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16mf2x7(float16_t *rs1, vuint64m2_t vs2, +void test_vsuxseg7ei64_v_f16mf2x7(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64_v_f16mf2x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16m1x7(float16_t *rs1, vuint64m4_t vs2, +void test_vsuxseg7ei64_v_f16m1x7(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64_v_f16m1x7(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg7ei64_v_u64m1x7(uint64_t *rs1, vuint64m1_t vs2, return __riscv_vsuxseg7ei64_v_u64m1x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg7ei64_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64_v_f16mf4x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg7ei64_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64_v_f16mf2x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x7_t vs3, - size_t vl) { +void test_vsuxseg7ei64_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64_v_f16m1x7_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg7ei8.c b/auto-generated/api-testing/vsuxseg7ei8.c index aaf79b3a3..9491c1f91 100644 --- a/auto-generated/api-testing/vsuxseg7ei8.c +++ b/auto-generated/api-testing/vsuxseg7ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg7ei8_v_f16mf4x7(float16_t *rs1, vuint8mf8_t vs2, +void test_vsuxseg7ei8_v_f16mf4x7(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8_v_f16mf4x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16mf2x7(float16_t *rs1, vuint8mf4_t vs2, +void test_vsuxseg7ei8_v_f16mf2x7(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8_v_f16mf2x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16m1x7(float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg7ei8_v_f16m1x7(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8_v_f16m1x7(rs1, vs2, vs3, vl); } @@ -135,19 +135,17 @@ void test_vsuxseg7ei8_v_u64m1x7(uint64_t *rs1, vuint8mf8_t vs2, return __riscv_vsuxseg7ei8_v_u64m1x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x7_t vs3, - size_t vl) { +void test_vsuxseg7ei8_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8_v_f16mf4x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x7_t vs3, - size_t vl) { +void test_vsuxseg7ei8_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8_v_f16mf2x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg7ei8_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8_v_f16m1x7_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg8ei16.c b/auto-generated/api-testing/vsuxseg8ei16.c index 1ebb4cee4..ca5e19856 100644 --- a/auto-generated/api-testing/vsuxseg8ei16.c +++ b/auto-generated/api-testing/vsuxseg8ei16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg8ei16_v_f16mf4x8(float16_t *rs1, vuint16mf4_t vs2, +void test_vsuxseg8ei16_v_f16mf4x8(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16_v_f16mf4x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16mf2x8(float16_t *rs1, vuint16mf2_t vs2, +void test_vsuxseg8ei16_v_f16mf2x8(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16_v_f16mf2x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16m1x8(float16_t *rs1, vuint16m1_t vs2, +void test_vsuxseg8ei16_v_f16m1x8(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16_v_f16m1x8(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg8ei16_v_u64m1x8(uint64_t *rs1, vuint16mf4_t vs2, return __riscv_vsuxseg8ei16_v_u64m1x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg8ei16_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16_v_f16mf4x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg8ei16_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16_v_f16mf2x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x8_t vs3, - size_t vl) { +void test_vsuxseg8ei16_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16_v_f16m1x8_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg8ei32.c b/auto-generated/api-testing/vsuxseg8ei32.c index 88f0f79f7..f2e6a7020 100644 --- a/auto-generated/api-testing/vsuxseg8ei32.c +++ b/auto-generated/api-testing/vsuxseg8ei32.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg8ei32_v_f16mf4x8(float16_t *rs1, vuint32mf2_t vs2, +void test_vsuxseg8ei32_v_f16mf4x8(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32_v_f16mf4x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16mf2x8(float16_t *rs1, vuint32m1_t vs2, +void test_vsuxseg8ei32_v_f16mf2x8(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32_v_f16mf2x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16m1x8(float16_t *rs1, vuint32m2_t vs2, +void test_vsuxseg8ei32_v_f16m1x8(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32_v_f16m1x8(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg8ei32_v_u64m1x8(uint64_t *rs1, vuint32mf2_t vs2, return __riscv_vsuxseg8ei32_v_u64m1x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg8ei32_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32_v_f16mf4x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg8ei32_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32_v_f16mf2x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x8_t vs3, - size_t vl) { +void test_vsuxseg8ei32_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32_v_f16m1x8_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg8ei64.c b/auto-generated/api-testing/vsuxseg8ei64.c index 0e9299d76..06bc74e17 100644 --- a/auto-generated/api-testing/vsuxseg8ei64.c +++ b/auto-generated/api-testing/vsuxseg8ei64.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg8ei64_v_f16mf4x8(float16_t *rs1, vuint64m1_t vs2, +void test_vsuxseg8ei64_v_f16mf4x8(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64_v_f16mf4x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16mf2x8(float16_t *rs1, vuint64m2_t vs2, +void test_vsuxseg8ei64_v_f16mf2x8(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64_v_f16mf2x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16m1x8(float16_t *rs1, vuint64m4_t vs2, +void test_vsuxseg8ei64_v_f16m1x8(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64_v_f16m1x8(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg8ei64_v_u64m1x8(uint64_t *rs1, vuint64m1_t vs2, return __riscv_vsuxseg8ei64_v_u64m1x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg8ei64_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64_v_f16mf4x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg8ei64_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64_v_f16mf2x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x8_t vs3, - size_t vl) { +void test_vsuxseg8ei64_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64_v_f16m1x8_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/api-testing/vsuxseg8ei8.c b/auto-generated/api-testing/vsuxseg8ei8.c index f7f7c4160..d75c0dc9b 100644 --- a/auto-generated/api-testing/vsuxseg8ei8.c +++ b/auto-generated/api-testing/vsuxseg8ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg8ei8_v_f16mf4x8(float16_t *rs1, vuint8mf8_t vs2, +void test_vsuxseg8ei8_v_f16mf4x8(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8_v_f16mf4x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16mf2x8(float16_t *rs1, vuint8mf4_t vs2, +void test_vsuxseg8ei8_v_f16mf2x8(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8_v_f16mf2x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16m1x8(float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg8ei8_v_f16m1x8(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8_v_f16m1x8(rs1, vs2, vs3, vl); } @@ -135,19 +135,17 @@ void test_vsuxseg8ei8_v_u64m1x8(uint64_t *rs1, vuint8mf8_t vs2, return __riscv_vsuxseg8ei8_v_u64m1x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x8_t vs3, - size_t vl) { +void test_vsuxseg8ei8_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8_v_f16mf4x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x8_t vs3, - size_t vl) { +void test_vsuxseg8ei8_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8_v_f16mf2x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg8ei8_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8_v_f16m1x8_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vle16.c b/auto-generated/gnu-api-tests/vle16.c index 4fdfc79e2..a0cd5ae34 100644 --- a/auto-generated/gnu-api-tests/vle16.c +++ b/auto-generated/gnu-api-tests/vle16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vle16_v_f16mf4(const float16_t *rs1, size_t vl) { +vfloat16mf4_t test_vle16_v_f16mf4(const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf4(rs1, vl); } -vfloat16mf2_t test_vle16_v_f16mf2(const float16_t *rs1, size_t vl) { +vfloat16mf2_t test_vle16_v_f16mf2(const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf2(rs1, vl); } -vfloat16m1_t test_vle16_v_f16m1(const float16_t *rs1, size_t vl) { +vfloat16m1_t test_vle16_v_f16m1(const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m1(rs1, vl); } -vfloat16m2_t test_vle16_v_f16m2(const float16_t *rs1, size_t vl) { +vfloat16m2_t test_vle16_v_f16m2(const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m2(rs1, vl); } -vfloat16m4_t test_vle16_v_f16m4(const float16_t *rs1, size_t vl) { +vfloat16m4_t test_vle16_v_f16m4(const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m4(rs1, vl); } -vfloat16m8_t test_vle16_v_f16m8(const float16_t *rs1, size_t vl) { +vfloat16m8_t test_vle16_v_f16m8(const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m8(rs1, vl); } @@ -79,27 +79,27 @@ vuint16m8_t test_vle16_v_u16m8(const uint16_t *rs1, size_t vl) { return __riscv_vle16_v_u16m8(rs1, vl); } -vfloat16mf4_t test_vle16_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf4_t test_vle16_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf4_m(vm, rs1, vl); } -vfloat16mf2_t test_vle16_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf2_t test_vle16_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf2_m(vm, rs1, vl); } -vfloat16m1_t test_vle16_v_f16m1_m(vbool16_t vm, const float16_t *rs1, size_t vl) { +vfloat16m1_t test_vle16_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m1_m(vm, rs1, vl); } -vfloat16m2_t test_vle16_v_f16m2_m(vbool8_t vm, const float16_t *rs1, size_t vl) { +vfloat16m2_t test_vle16_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m2_m(vm, rs1, vl); } -vfloat16m4_t test_vle16_v_f16m4_m(vbool4_t vm, const float16_t *rs1, size_t vl) { +vfloat16m4_t test_vle16_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m4_m(vm, rs1, vl); } -vfloat16m8_t test_vle16_v_f16m8_m(vbool2_t vm, const float16_t *rs1, size_t vl) { +vfloat16m8_t test_vle16_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m8_m(vm, rs1, vl); } diff --git a/auto-generated/gnu-api-tests/vle16ff.c b/auto-generated/gnu-api-tests/vle16ff.c index 54232bdd7..28ba20f1f 100644 --- a/auto-generated/gnu-api-tests/vle16ff.c +++ b/auto-generated/gnu-api-tests/vle16ff.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vle16ff_v_f16mf4(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4_t test_vle16ff_v_f16mf4(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf4(rs1, new_vl, vl); } -vfloat16mf2_t test_vle16ff_v_f16mf2(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2_t test_vle16ff_v_f16mf2(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf2(rs1, new_vl, vl); } -vfloat16m1_t test_vle16ff_v_f16m1(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1_t test_vle16ff_v_f16m1(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m1(rs1, new_vl, vl); } -vfloat16m2_t test_vle16ff_v_f16m2(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2_t test_vle16ff_v_f16m2(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m2(rs1, new_vl, vl); } -vfloat16m4_t test_vle16ff_v_f16m4(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4_t test_vle16ff_v_f16m4(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m4(rs1, new_vl, vl); } -vfloat16m8_t test_vle16ff_v_f16m8(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m8_t test_vle16ff_v_f16m8(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m8(rs1, new_vl, vl); } @@ -79,27 +79,27 @@ vuint16m8_t test_vle16ff_v_u16m8(const uint16_t *rs1, size_t *new_vl, size_t vl) return __riscv_vle16ff_v_u16m8(rs1, new_vl, vl); } -vfloat16mf4_t test_vle16ff_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4_t test_vle16ff_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf4_m(vm, rs1, new_vl, vl); } -vfloat16mf2_t test_vle16ff_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2_t test_vle16ff_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf2_m(vm, rs1, new_vl, vl); } -vfloat16m1_t test_vle16ff_v_f16m1_m(vbool16_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1_t test_vle16ff_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m1_m(vm, rs1, new_vl, vl); } -vfloat16m2_t test_vle16ff_v_f16m2_m(vbool8_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2_t test_vle16ff_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m2_m(vm, rs1, new_vl, vl); } -vfloat16m4_t test_vle16ff_v_f16m4_m(vbool4_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4_t test_vle16ff_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m4_m(vm, rs1, new_vl, vl); } -vfloat16m8_t test_vle16ff_v_f16m8_m(vbool2_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m8_t test_vle16ff_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m8_m(vm, rs1, new_vl, vl); } diff --git a/auto-generated/gnu-api-tests/vloxei16.c b/auto-generated/gnu-api-tests/vloxei16.c index 431a6edc0..0e240b58d 100644 --- a/auto-generated/gnu-api-tests/vloxei16.c +++ b/auto-generated/gnu-api-tests/vloxei16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei16_v_f16mf4(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei16_v_f16mf4(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei16_v_f16mf2(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vloxei16_v_f16m1(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2(const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vloxei16_v_f16m2(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m2(rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4(const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vloxei16_v_f16m4(const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m4(rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8(const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vloxei16_v_f16m8(const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m8(rs1, rs2, vl); } @@ -235,27 +235,27 @@ vuint64m8_t test_vloxei16_v_u64m8(const uint64_t *rs1, vuint16m2_t rs2, size_t v return __riscv_vloxei16_v_u64m8(rs1, rs2, vl); } -vfloat16mf4_t test_vloxei16_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei16_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei16_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vloxei16_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2_m(vbool8_t vm, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vloxei16_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m2_m(vm, rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4_m(vbool4_t vm, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vloxei16_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m4_m(vm, rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8_m(vbool2_t vm, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vloxei16_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxei32.c b/auto-generated/gnu-api-tests/vloxei32.c index c39444457..e485d659f 100644 --- a/auto-generated/gnu-api-tests/vloxei32.c +++ b/auto-generated/gnu-api-tests/vloxei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei32_v_f16mf4(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei32_v_f16mf4(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei32_v_f16mf2(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei32_v_f16m1(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2(const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vloxei32_v_f16m2(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m2(rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4(const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vloxei32_v_f16m4(const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m4(rs1, rs2, vl); } @@ -215,23 +215,23 @@ vuint64m8_t test_vloxei32_v_u64m8(const uint64_t *rs1, vuint32m4_t rs2, size_t v return __riscv_vloxei32_v_u64m8(rs1, rs2, vl); } -vfloat16mf4_t test_vloxei32_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei32_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei32_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei32_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2_m(vbool8_t vm, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vloxei32_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m2_m(vm, rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4_m(vbool4_t vm, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vloxei32_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxei64.c b/auto-generated/gnu-api-tests/vloxei64.c index 483b5eff3..170d32905 100644 --- a/auto-generated/gnu-api-tests/vloxei64.c +++ b/auto-generated/gnu-api-tests/vloxei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei64_v_f16mf4(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei64_v_f16mf4(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei64_v_f16mf2(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vloxei64_v_f16m1(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2(const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vloxei64_v_f16m2(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m2(rs1, rs2, vl); } @@ -183,19 +183,19 @@ vuint64m8_t test_vloxei64_v_u64m8(const uint64_t *rs1, vuint64m8_t rs2, size_t v return __riscv_vloxei64_v_u64m8(rs1, rs2, vl); } -vfloat16mf4_t test_vloxei64_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei64_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei64_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vloxei64_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2_m(vbool8_t vm, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vloxei64_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxei8.c b/auto-generated/gnu-api-tests/vloxei8.c index c042892f0..3b879cb06 100644 --- a/auto-generated/gnu-api-tests/vloxei8.c +++ b/auto-generated/gnu-api-tests/vloxei8.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei8_v_f16mf4(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei8_v_f16mf4(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei8_v_f16mf2(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei8_v_f16m1(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2(const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vloxei8_v_f16m2(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m2(rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4(const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vloxei8_v_f16m4(const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m4(rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8(const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vloxei8_v_f16m8(const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m8(rs1, rs2, vl); } @@ -243,27 +243,27 @@ vuint64m8_t test_vloxei8_v_u64m8(const uint64_t *rs1, vuint8m1_t rs2, size_t vl) return __riscv_vloxei8_v_u64m8(rs1, rs2, vl); } -vfloat16mf4_t test_vloxei8_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei8_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei8_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei8_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2_m(vbool8_t vm, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vloxei8_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m2_m(vm, rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4_m(vbool4_t vm, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vloxei8_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m4_m(vm, rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8_m(vbool2_t vm, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vloxei8_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg2ei16.c b/auto-generated/gnu-api-tests/vloxseg2ei16.c index c9c38a807..b70200a27 100644 --- a/auto-generated/gnu-api-tests/vloxseg2ei16.c +++ b/auto-generated/gnu-api-tests/vloxseg2ei16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2(const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m2x2(rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2(const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2(const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m4x2(rs1, rs2, vl); } @@ -199,23 +199,23 @@ vuint64m4x2_t test_vloxseg2ei16_v_u64m4x2(const uint64_t *rs1, vuint16m1_t rs2, return __riscv_vloxseg2ei16_v_u64m4x2(rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf4x2_m(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m2x2_m(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m4x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg2ei32.c b/auto-generated/gnu-api-tests/vloxseg2ei32.c index c1cfd8669..9105907e3 100644 --- a/auto-generated/gnu-api-tests/vloxseg2ei32.c +++ b/auto-generated/gnu-api-tests/vloxseg2ei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2(const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m2x2(rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2(const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2(const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m4x2(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m4x2_t test_vloxseg2ei32_v_u64m4x2(const uint64_t *rs1, vuint32m2_t rs2, return __riscv_vloxseg2ei32_v_u64m4x2(rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf4x2_m(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m2x2_m(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m4x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg2ei64.c b/auto-generated/gnu-api-tests/vloxseg2ei64.c index 9ef2aba2f..668296e6b 100644 --- a/auto-generated/gnu-api-tests/vloxseg2ei64.c +++ b/auto-generated/gnu-api-tests/vloxseg2ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2(const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m2x2(rs1, rs2, vl); } @@ -171,19 +171,19 @@ vuint64m4x2_t test_vloxseg2ei64_v_u64m4x2(const uint64_t *rs1, vuint64m4_t rs2, return __riscv_vloxseg2ei64_v_u64m4x2(rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf4x2_m(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m2x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg2ei8.c b/auto-generated/gnu-api-tests/vloxseg2ei8.c index e35d81cea..97e024115 100644 --- a/auto-generated/gnu-api-tests/vloxseg2ei8.c +++ b/auto-generated/gnu-api-tests/vloxseg2ei8.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2(const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m2x2(rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2(const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2(const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m4x2(rs1, rs2, vl); } @@ -199,23 +199,23 @@ vuint64m4x2_t test_vloxseg2ei8_v_u64m4x2(const uint64_t *rs1, vuint8mf2_t rs2, s return __riscv_vloxseg2ei8_v_u64m4x2(rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf4x2_m(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m2x2_m(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m4x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg3ei16.c b/auto-generated/gnu-api-tests/vloxseg3ei16.c index abc811055..b3702b267 100644 --- a/auto-generated/gnu-api-tests/vloxseg3ei16.c +++ b/auto-generated/gnu-api-tests/vloxseg3ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3(const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m2x3(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vloxseg3ei16_v_u64m2x3(const uint64_t *rs1, vuint16mf2_t rs2, return __riscv_vloxseg3ei16_v_u64m2x3(rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf4x3_m(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg3ei32.c b/auto-generated/gnu-api-tests/vloxseg3ei32.c index c01b4d7d9..5300fbce6 100644 --- a/auto-generated/gnu-api-tests/vloxseg3ei32.c +++ b/auto-generated/gnu-api-tests/vloxseg3ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3(const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m2x3(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vloxseg3ei32_v_u64m2x3(const uint64_t *rs1, vuint32m1_t rs2, return __riscv_vloxseg3ei32_v_u64m2x3(rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf4x3_m(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg3ei64.c b/auto-generated/gnu-api-tests/vloxseg3ei64.c index 9193f6bd0..d8d789526 100644 --- a/auto-generated/gnu-api-tests/vloxseg3ei64.c +++ b/auto-generated/gnu-api-tests/vloxseg3ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3(const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m2x3(rs1, rs2, vl); } @@ -147,19 +147,19 @@ vuint64m2x3_t test_vloxseg3ei64_v_u64m2x3(const uint64_t *rs1, vuint64m2_t rs2, return __riscv_vloxseg3ei64_v_u64m2x3(rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf4x3_m(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg3ei8.c b/auto-generated/gnu-api-tests/vloxseg3ei8.c index fa2f785fb..6fb2ef2b8 100644 --- a/auto-generated/gnu-api-tests/vloxseg3ei8.c +++ b/auto-generated/gnu-api-tests/vloxseg3ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3(const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m2x3(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vloxseg3ei8_v_u64m2x3(const uint64_t *rs1, vuint8mf4_t rs2, s return __riscv_vloxseg3ei8_v_u64m2x3(rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf4x3_m(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg4ei16.c b/auto-generated/gnu-api-tests/vloxseg4ei16.c index e7690edb9..0f3f4bcb6 100644 --- a/auto-generated/gnu-api-tests/vloxseg4ei16.c +++ b/auto-generated/gnu-api-tests/vloxseg4ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4(const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m2x4(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vloxseg4ei16_v_u64m2x4(const uint64_t *rs1, vuint16mf2_t rs2, return __riscv_vloxseg4ei16_v_u64m2x4(rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf4x4_m(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg4ei32.c b/auto-generated/gnu-api-tests/vloxseg4ei32.c index 0e702ae87..2737b80c2 100644 --- a/auto-generated/gnu-api-tests/vloxseg4ei32.c +++ b/auto-generated/gnu-api-tests/vloxseg4ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4(const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m2x4(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vloxseg4ei32_v_u64m2x4(const uint64_t *rs1, vuint32m1_t rs2, return __riscv_vloxseg4ei32_v_u64m2x4(rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf4x4_m(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg4ei64.c b/auto-generated/gnu-api-tests/vloxseg4ei64.c index 0f29c5fed..fad91904a 100644 --- a/auto-generated/gnu-api-tests/vloxseg4ei64.c +++ b/auto-generated/gnu-api-tests/vloxseg4ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4(const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m2x4(rs1, rs2, vl); } @@ -147,19 +147,19 @@ vuint64m2x4_t test_vloxseg4ei64_v_u64m2x4(const uint64_t *rs1, vuint64m2_t rs2, return __riscv_vloxseg4ei64_v_u64m2x4(rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf4x4_m(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg4ei8.c b/auto-generated/gnu-api-tests/vloxseg4ei8.c index 36eb963e9..d7c1f2cff 100644 --- a/auto-generated/gnu-api-tests/vloxseg4ei8.c +++ b/auto-generated/gnu-api-tests/vloxseg4ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4(const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m2x4(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vloxseg4ei8_v_u64m2x4(const uint64_t *rs1, vuint8mf4_t rs2, s return __riscv_vloxseg4ei8_v_u64m2x4(rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf4x4_m(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg5ei16.c b/auto-generated/gnu-api-tests/vloxseg5ei16.c index 724171dcb..8866a9ded 100644 --- a/auto-generated/gnu-api-tests/vloxseg5ei16.c +++ b/auto-generated/gnu-api-tests/vloxseg5ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16m1x5(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vloxseg5ei16_v_u64m1x5(const uint64_t *rs1, vuint16mf4_t rs2, return __riscv_vloxseg5ei16_v_u64m1x5(rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf4x5_m(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg5ei32.c b/auto-generated/gnu-api-tests/vloxseg5ei32.c index 4a9e2a7f8..bcdb1425a 100644 --- a/auto-generated/gnu-api-tests/vloxseg5ei32.c +++ b/auto-generated/gnu-api-tests/vloxseg5ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16m1x5(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vloxseg5ei32_v_u64m1x5(const uint64_t *rs1, vuint32mf2_t rs2, return __riscv_vloxseg5ei32_v_u64m1x5(rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf4x5_m(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg5ei64.c b/auto-generated/gnu-api-tests/vloxseg5ei64.c index 5df590d87..ecc32946c 100644 --- a/auto-generated/gnu-api-tests/vloxseg5ei64.c +++ b/auto-generated/gnu-api-tests/vloxseg5ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16m1x5(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vloxseg5ei64_v_u64m1x5(const uint64_t *rs1, vuint64m1_t rs2, return __riscv_vloxseg5ei64_v_u64m1x5(rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf4x5_m(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg5ei8.c b/auto-generated/gnu-api-tests/vloxseg5ei8.c index 90fccb8e2..91f949da5 100644 --- a/auto-generated/gnu-api-tests/vloxseg5ei8.c +++ b/auto-generated/gnu-api-tests/vloxseg5ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16m1x5(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vloxseg5ei8_v_u64m1x5(const uint64_t *rs1, vuint8mf8_t rs2, s return __riscv_vloxseg5ei8_v_u64m1x5(rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf4x5_m(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg6ei16.c b/auto-generated/gnu-api-tests/vloxseg6ei16.c index a90839d46..fcf44fe15 100644 --- a/auto-generated/gnu-api-tests/vloxseg6ei16.c +++ b/auto-generated/gnu-api-tests/vloxseg6ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16m1x6(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vloxseg6ei16_v_u64m1x6(const uint64_t *rs1, vuint16mf4_t rs2, return __riscv_vloxseg6ei16_v_u64m1x6(rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf4x6_m(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg6ei32.c b/auto-generated/gnu-api-tests/vloxseg6ei32.c index a6f7580cd..cb8683a91 100644 --- a/auto-generated/gnu-api-tests/vloxseg6ei32.c +++ b/auto-generated/gnu-api-tests/vloxseg6ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16m1x6(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vloxseg6ei32_v_u64m1x6(const uint64_t *rs1, vuint32mf2_t rs2, return __riscv_vloxseg6ei32_v_u64m1x6(rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf4x6_m(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg6ei64.c b/auto-generated/gnu-api-tests/vloxseg6ei64.c index d2a79c950..05ab0c7cd 100644 --- a/auto-generated/gnu-api-tests/vloxseg6ei64.c +++ b/auto-generated/gnu-api-tests/vloxseg6ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16m1x6(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vloxseg6ei64_v_u64m1x6(const uint64_t *rs1, vuint64m1_t rs2, return __riscv_vloxseg6ei64_v_u64m1x6(rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf4x6_m(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg6ei8.c b/auto-generated/gnu-api-tests/vloxseg6ei8.c index df3ff7f34..87c20d55a 100644 --- a/auto-generated/gnu-api-tests/vloxseg6ei8.c +++ b/auto-generated/gnu-api-tests/vloxseg6ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16m1x6(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vloxseg6ei8_v_u64m1x6(const uint64_t *rs1, vuint8mf8_t rs2, s return __riscv_vloxseg6ei8_v_u64m1x6(rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf4x6_m(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg7ei16.c b/auto-generated/gnu-api-tests/vloxseg7ei16.c index cc1c57155..23e8bcf1c 100644 --- a/auto-generated/gnu-api-tests/vloxseg7ei16.c +++ b/auto-generated/gnu-api-tests/vloxseg7ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16m1x7(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vloxseg7ei16_v_u64m1x7(const uint64_t *rs1, vuint16mf4_t rs2, return __riscv_vloxseg7ei16_v_u64m1x7(rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf4x7_m(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg7ei32.c b/auto-generated/gnu-api-tests/vloxseg7ei32.c index 8b3d43697..7b7feeb06 100644 --- a/auto-generated/gnu-api-tests/vloxseg7ei32.c +++ b/auto-generated/gnu-api-tests/vloxseg7ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16m1x7(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vloxseg7ei32_v_u64m1x7(const uint64_t *rs1, vuint32mf2_t rs2, return __riscv_vloxseg7ei32_v_u64m1x7(rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf4x7_m(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg7ei64.c b/auto-generated/gnu-api-tests/vloxseg7ei64.c index 5886a8dc5..c4f2c7e65 100644 --- a/auto-generated/gnu-api-tests/vloxseg7ei64.c +++ b/auto-generated/gnu-api-tests/vloxseg7ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16m1x7(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vloxseg7ei64_v_u64m1x7(const uint64_t *rs1, vuint64m1_t rs2, return __riscv_vloxseg7ei64_v_u64m1x7(rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf4x7_m(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg7ei8.c b/auto-generated/gnu-api-tests/vloxseg7ei8.c index 2958de68f..2a63b3db6 100644 --- a/auto-generated/gnu-api-tests/vloxseg7ei8.c +++ b/auto-generated/gnu-api-tests/vloxseg7ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16m1x7(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vloxseg7ei8_v_u64m1x7(const uint64_t *rs1, vuint8mf8_t rs2, s return __riscv_vloxseg7ei8_v_u64m1x7(rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf4x7_m(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg8ei16.c b/auto-generated/gnu-api-tests/vloxseg8ei16.c index 56885d14e..7cd3340f1 100644 --- a/auto-generated/gnu-api-tests/vloxseg8ei16.c +++ b/auto-generated/gnu-api-tests/vloxseg8ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16m1x8(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vloxseg8ei16_v_u64m1x8(const uint64_t *rs1, vuint16mf4_t rs2, return __riscv_vloxseg8ei16_v_u64m1x8(rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf4x8_m(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg8ei32.c b/auto-generated/gnu-api-tests/vloxseg8ei32.c index 96e30f1ab..1cb950e79 100644 --- a/auto-generated/gnu-api-tests/vloxseg8ei32.c +++ b/auto-generated/gnu-api-tests/vloxseg8ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16m1x8(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vloxseg8ei32_v_u64m1x8(const uint64_t *rs1, vuint32mf2_t rs2, return __riscv_vloxseg8ei32_v_u64m1x8(rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf4x8_m(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg8ei64.c b/auto-generated/gnu-api-tests/vloxseg8ei64.c index 9d8b27140..51fbda6ca 100644 --- a/auto-generated/gnu-api-tests/vloxseg8ei64.c +++ b/auto-generated/gnu-api-tests/vloxseg8ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16m1x8(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vloxseg8ei64_v_u64m1x8(const uint64_t *rs1, vuint64m1_t rs2, return __riscv_vloxseg8ei64_v_u64m1x8(rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf4x8_m(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vloxseg8ei8.c b/auto-generated/gnu-api-tests/vloxseg8ei8.c index 864015e3b..7340f39ae 100644 --- a/auto-generated/gnu-api-tests/vloxseg8ei8.c +++ b/auto-generated/gnu-api-tests/vloxseg8ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16m1x8(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vloxseg8ei8_v_u64m1x8(const uint64_t *rs1, vuint8mf8_t rs2, s return __riscv_vloxseg8ei8_v_u64m1x8(rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf4x8_m(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vlse16.c b/auto-generated/gnu-api-tests/vlse16.c index 96a71f258..cc915c210 100644 --- a/auto-generated/gnu-api-tests/vlse16.c +++ b/auto-generated/gnu-api-tests/vlse16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vlse16_v_f16mf4(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4_t test_vlse16_v_f16mf4(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vlse16_v_f16mf2(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2_t test_vlse16_v_f16mf2(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vlse16_v_f16m1(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1_t test_vlse16_v_f16m1(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vlse16_v_f16m2(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2_t test_vlse16_v_f16m2(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m2(rs1, rs2, vl); } -vfloat16m4_t test_vlse16_v_f16m4(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4_t test_vlse16_v_f16m4(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m4(rs1, rs2, vl); } -vfloat16m8_t test_vlse16_v_f16m8(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m8_t test_vlse16_v_f16m8(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m8(rs1, rs2, vl); } @@ -79,27 +79,27 @@ vuint16m8_t test_vlse16_v_u16m8(const uint16_t *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_u16m8(rs1, rs2, vl); } -vfloat16mf4_t test_vlse16_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4_t test_vlse16_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vlse16_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2_t test_vlse16_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vlse16_v_f16m1_m(vbool16_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1_t test_vlse16_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vlse16_v_f16m2_m(vbool8_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2_t test_vlse16_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m2_m(vm, rs1, rs2, vl); } -vfloat16m4_t test_vlse16_v_f16m4_m(vbool4_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4_t test_vlse16_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m4_m(vm, rs1, rs2, vl); } -vfloat16m8_t test_vlse16_v_f16m8_m(vbool2_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m8_t test_vlse16_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vlseg2e16.c b/auto-generated/gnu-api-tests/vlseg2e16.c index f2fac05a5..bd7584cbf 100644 --- a/auto-generated/gnu-api-tests/vlseg2e16.c +++ b/auto-generated/gnu-api-tests/vlseg2e16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2(const float16_t *rs1, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2(const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf4x2(rs1, vl); } -vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2(const float16_t *rs1, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2(const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf2x2(rs1, vl); } -vfloat16m1x2_t test_vlseg2e16_v_f16m1x2(const float16_t *rs1, size_t vl) { +vfloat16m1x2_t test_vlseg2e16_v_f16m1x2(const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m1x2(rs1, vl); } -vfloat16m2x2_t test_vlseg2e16_v_f16m2x2(const float16_t *rs1, size_t vl) { +vfloat16m2x2_t test_vlseg2e16_v_f16m2x2(const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m2x2(rs1, vl); } -vfloat16m4x2_t test_vlseg2e16_v_f16m4x2(const float16_t *rs1, size_t vl) { +vfloat16m4x2_t test_vlseg2e16_v_f16m4x2(const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m4x2(rs1, vl); } @@ -67,23 +67,23 @@ vuint16m4x2_t test_vlseg2e16_v_u16m4x2(const uint16_t *rs1, size_t vl) { return __riscv_vlseg2e16_v_u16m4x2(rs1, vl); } -vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf4x2_m(vm, rs1, vl); } -vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf2x2_m(vm, rs1, vl); } -vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, size_t vl) { +vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m1x2_m(vm, rs1, vl); } -vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, size_t vl) { +vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m2x2_m(vm, rs1, vl); } -vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, size_t vl) { +vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m4x2_m(vm, rs1, vl); } diff --git a/auto-generated/gnu-api-tests/vlseg2e16ff.c b/auto-generated/gnu-api-tests/vlseg2e16ff.c index c946f3f97..008320b29 100644 --- a/auto-generated/gnu-api-tests/vlseg2e16ff.c +++ b/auto-generated/gnu-api-tests/vlseg2e16ff.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf4x2(rs1, new_vl, vl); } -vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf2x2(rs1, new_vl, vl); } -vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m1x2(rs1, new_vl, vl); } -vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m2x2(rs1, new_vl, vl); } -vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m4x2(rs1, new_vl, vl); } @@ -67,23 +67,23 @@ vuint16m4x2_t test_vlseg2e16ff_v_u16m4x2(const uint16_t *rs1, size_t *new_vl, si return __riscv_vlseg2e16ff_v_u16m4x2(rs1, new_vl, vl); } -vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf4x2_m(vm, rs1, new_vl, vl); } -vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf2x2_m(vm, rs1, new_vl, vl); } -vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m1x2_m(vm, rs1, new_vl, vl); } -vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m2x2_m(vm, rs1, new_vl, vl); } -vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m4x2_m(vm, rs1, new_vl, vl); } diff --git a/auto-generated/gnu-api-tests/vlseg3e16.c b/auto-generated/gnu-api-tests/vlseg3e16.c index 9f0f6fb08..08ad21fd8 100644 --- a/auto-generated/gnu-api-tests/vlseg3e16.c +++ b/auto-generated/gnu-api-tests/vlseg3e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3(const float16_t *rs1, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3(const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf4x3(rs1, vl); } -vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3(const float16_t *rs1, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3(const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf2x3(rs1, vl); } -vfloat16m1x3_t test_vlseg3e16_v_f16m1x3(const float16_t *rs1, size_t vl) { +vfloat16m1x3_t test_vlseg3e16_v_f16m1x3(const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m1x3(rs1, vl); } -vfloat16m2x3_t test_vlseg3e16_v_f16m2x3(const float16_t *rs1, size_t vl) { +vfloat16m2x3_t test_vlseg3e16_v_f16m2x3(const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m2x3(rs1, vl); } @@ -55,19 +55,19 @@ vuint16m2x3_t test_vlseg3e16_v_u16m2x3(const uint16_t *rs1, size_t vl) { return __riscv_vlseg3e16_v_u16m2x3(rs1, vl); } -vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf4x3_m(vm, rs1, vl); } -vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf2x3_m(vm, rs1, vl); } -vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, size_t vl) { +vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m1x3_m(vm, rs1, vl); } -vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, size_t vl) { +vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m2x3_m(vm, rs1, vl); } diff --git a/auto-generated/gnu-api-tests/vlseg3e16ff.c b/auto-generated/gnu-api-tests/vlseg3e16ff.c index 3274724cc..66c828e51 100644 --- a/auto-generated/gnu-api-tests/vlseg3e16ff.c +++ b/auto-generated/gnu-api-tests/vlseg3e16ff.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf4x3(rs1, new_vl, vl); } -vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf2x3(rs1, new_vl, vl); } -vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m1x3(rs1, new_vl, vl); } -vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m2x3(rs1, new_vl, vl); } @@ -55,19 +55,19 @@ vuint16m2x3_t test_vlseg3e16ff_v_u16m2x3(const uint16_t *rs1, size_t *new_vl, si return __riscv_vlseg3e16ff_v_u16m2x3(rs1, new_vl, vl); } -vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf4x3_m(vm, rs1, new_vl, vl); } -vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf2x3_m(vm, rs1, new_vl, vl); } -vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m1x3_m(vm, rs1, new_vl, vl); } -vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m2x3_m(vm, rs1, new_vl, vl); } diff --git a/auto-generated/gnu-api-tests/vlseg4e16.c b/auto-generated/gnu-api-tests/vlseg4e16.c index af6b5e699..14a06b15a 100644 --- a/auto-generated/gnu-api-tests/vlseg4e16.c +++ b/auto-generated/gnu-api-tests/vlseg4e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4(const float16_t *rs1, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4(const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf4x4(rs1, vl); } -vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4(const float16_t *rs1, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4(const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf2x4(rs1, vl); } -vfloat16m1x4_t test_vlseg4e16_v_f16m1x4(const float16_t *rs1, size_t vl) { +vfloat16m1x4_t test_vlseg4e16_v_f16m1x4(const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m1x4(rs1, vl); } -vfloat16m2x4_t test_vlseg4e16_v_f16m2x4(const float16_t *rs1, size_t vl) { +vfloat16m2x4_t test_vlseg4e16_v_f16m2x4(const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m2x4(rs1, vl); } @@ -55,19 +55,19 @@ vuint16m2x4_t test_vlseg4e16_v_u16m2x4(const uint16_t *rs1, size_t vl) { return __riscv_vlseg4e16_v_u16m2x4(rs1, vl); } -vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf4x4_m(vm, rs1, vl); } -vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf2x4_m(vm, rs1, vl); } -vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, size_t vl) { +vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m1x4_m(vm, rs1, vl); } -vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, size_t vl) { +vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m2x4_m(vm, rs1, vl); } diff --git a/auto-generated/gnu-api-tests/vlseg4e16ff.c b/auto-generated/gnu-api-tests/vlseg4e16ff.c index 43729ec16..536bed2e4 100644 --- a/auto-generated/gnu-api-tests/vlseg4e16ff.c +++ b/auto-generated/gnu-api-tests/vlseg4e16ff.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf4x4(rs1, new_vl, vl); } -vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf2x4(rs1, new_vl, vl); } -vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m1x4(rs1, new_vl, vl); } -vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m2x4(rs1, new_vl, vl); } @@ -55,19 +55,19 @@ vuint16m2x4_t test_vlseg4e16ff_v_u16m2x4(const uint16_t *rs1, size_t *new_vl, si return __riscv_vlseg4e16ff_v_u16m2x4(rs1, new_vl, vl); } -vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf4x4_m(vm, rs1, new_vl, vl); } -vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf2x4_m(vm, rs1, new_vl, vl); } -vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m1x4_m(vm, rs1, new_vl, vl); } -vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m2x4_m(vm, rs1, new_vl, vl); } diff --git a/auto-generated/gnu-api-tests/vlseg5e16.c b/auto-generated/gnu-api-tests/vlseg5e16.c index 2253e69ec..cb93f247c 100644 --- a/auto-generated/gnu-api-tests/vlseg5e16.c +++ b/auto-generated/gnu-api-tests/vlseg5e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5(const float16_t *rs1, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5(const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf4x5(rs1, vl); } -vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5(const float16_t *rs1, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5(const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf2x5(rs1, vl); } -vfloat16m1x5_t test_vlseg5e16_v_f16m1x5(const float16_t *rs1, size_t vl) { +vfloat16m1x5_t test_vlseg5e16_v_f16m1x5(const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16m1x5(rs1, vl); } @@ -43,15 +43,15 @@ vuint16m1x5_t test_vlseg5e16_v_u16m1x5(const uint16_t *rs1, size_t vl) { return __riscv_vlseg5e16_v_u16m1x5(rs1, vl); } -vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf4x5_m(vm, rs1, vl); } -vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf2x5_m(vm, rs1, vl); } -vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, size_t vl) { +vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16m1x5_m(vm, rs1, vl); } diff --git a/auto-generated/gnu-api-tests/vlseg5e16ff.c b/auto-generated/gnu-api-tests/vlseg5e16ff.c index 1c23509e8..2b6cd903e 100644 --- a/auto-generated/gnu-api-tests/vlseg5e16ff.c +++ b/auto-generated/gnu-api-tests/vlseg5e16ff.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf4x5(rs1, new_vl, vl); } -vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf2x5(rs1, new_vl, vl); } -vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16m1x5(rs1, new_vl, vl); } @@ -43,15 +43,15 @@ vuint16m1x5_t test_vlseg5e16ff_v_u16m1x5(const uint16_t *rs1, size_t *new_vl, si return __riscv_vlseg5e16ff_v_u16m1x5(rs1, new_vl, vl); } -vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf4x5_m(vm, rs1, new_vl, vl); } -vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf2x5_m(vm, rs1, new_vl, vl); } -vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16m1x5_m(vm, rs1, new_vl, vl); } diff --git a/auto-generated/gnu-api-tests/vlseg6e16.c b/auto-generated/gnu-api-tests/vlseg6e16.c index 97b97ef86..496dba250 100644 --- a/auto-generated/gnu-api-tests/vlseg6e16.c +++ b/auto-generated/gnu-api-tests/vlseg6e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6(const float16_t *rs1, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6(const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf4x6(rs1, vl); } -vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6(const float16_t *rs1, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6(const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf2x6(rs1, vl); } -vfloat16m1x6_t test_vlseg6e16_v_f16m1x6(const float16_t *rs1, size_t vl) { +vfloat16m1x6_t test_vlseg6e16_v_f16m1x6(const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16m1x6(rs1, vl); } @@ -43,15 +43,15 @@ vuint16m1x6_t test_vlseg6e16_v_u16m1x6(const uint16_t *rs1, size_t vl) { return __riscv_vlseg6e16_v_u16m1x6(rs1, vl); } -vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf4x6_m(vm, rs1, vl); } -vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf2x6_m(vm, rs1, vl); } -vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, size_t vl) { +vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16m1x6_m(vm, rs1, vl); } diff --git a/auto-generated/gnu-api-tests/vlseg6e16ff.c b/auto-generated/gnu-api-tests/vlseg6e16ff.c index 463c57039..9a79f209f 100644 --- a/auto-generated/gnu-api-tests/vlseg6e16ff.c +++ b/auto-generated/gnu-api-tests/vlseg6e16ff.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf4x6(rs1, new_vl, vl); } -vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf2x6(rs1, new_vl, vl); } -vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16m1x6(rs1, new_vl, vl); } @@ -43,15 +43,15 @@ vuint16m1x6_t test_vlseg6e16ff_v_u16m1x6(const uint16_t *rs1, size_t *new_vl, si return __riscv_vlseg6e16ff_v_u16m1x6(rs1, new_vl, vl); } -vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf4x6_m(vm, rs1, new_vl, vl); } -vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf2x6_m(vm, rs1, new_vl, vl); } -vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16m1x6_m(vm, rs1, new_vl, vl); } diff --git a/auto-generated/gnu-api-tests/vlseg7e16.c b/auto-generated/gnu-api-tests/vlseg7e16.c index 7f39c7c38..8aeedbfea 100644 --- a/auto-generated/gnu-api-tests/vlseg7e16.c +++ b/auto-generated/gnu-api-tests/vlseg7e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7(const float16_t *rs1, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7(const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf4x7(rs1, vl); } -vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7(const float16_t *rs1, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7(const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf2x7(rs1, vl); } -vfloat16m1x7_t test_vlseg7e16_v_f16m1x7(const float16_t *rs1, size_t vl) { +vfloat16m1x7_t test_vlseg7e16_v_f16m1x7(const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16m1x7(rs1, vl); } @@ -43,15 +43,15 @@ vuint16m1x7_t test_vlseg7e16_v_u16m1x7(const uint16_t *rs1, size_t vl) { return __riscv_vlseg7e16_v_u16m1x7(rs1, vl); } -vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf4x7_m(vm, rs1, vl); } -vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf2x7_m(vm, rs1, vl); } -vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, size_t vl) { +vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16m1x7_m(vm, rs1, vl); } diff --git a/auto-generated/gnu-api-tests/vlseg7e16ff.c b/auto-generated/gnu-api-tests/vlseg7e16ff.c index 789b8dd29..2d3039c95 100644 --- a/auto-generated/gnu-api-tests/vlseg7e16ff.c +++ b/auto-generated/gnu-api-tests/vlseg7e16ff.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf4x7(rs1, new_vl, vl); } -vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf2x7(rs1, new_vl, vl); } -vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16m1x7(rs1, new_vl, vl); } @@ -43,15 +43,15 @@ vuint16m1x7_t test_vlseg7e16ff_v_u16m1x7(const uint16_t *rs1, size_t *new_vl, si return __riscv_vlseg7e16ff_v_u16m1x7(rs1, new_vl, vl); } -vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf4x7_m(vm, rs1, new_vl, vl); } -vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf2x7_m(vm, rs1, new_vl, vl); } -vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16m1x7_m(vm, rs1, new_vl, vl); } diff --git a/auto-generated/gnu-api-tests/vlseg8e16.c b/auto-generated/gnu-api-tests/vlseg8e16.c index a7539a7be..91f25da97 100644 --- a/auto-generated/gnu-api-tests/vlseg8e16.c +++ b/auto-generated/gnu-api-tests/vlseg8e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8(const float16_t *rs1, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8(const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf4x8(rs1, vl); } -vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8(const float16_t *rs1, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8(const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf2x8(rs1, vl); } -vfloat16m1x8_t test_vlseg8e16_v_f16m1x8(const float16_t *rs1, size_t vl) { +vfloat16m1x8_t test_vlseg8e16_v_f16m1x8(const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16m1x8(rs1, vl); } @@ -43,15 +43,15 @@ vuint16m1x8_t test_vlseg8e16_v_u16m1x8(const uint16_t *rs1, size_t vl) { return __riscv_vlseg8e16_v_u16m1x8(rs1, vl); } -vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf4x8_m(vm, rs1, vl); } -vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf2x8_m(vm, rs1, vl); } -vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, size_t vl) { +vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16m1x8_m(vm, rs1, vl); } diff --git a/auto-generated/gnu-api-tests/vlseg8e16ff.c b/auto-generated/gnu-api-tests/vlseg8e16ff.c index 6a2adaa01..1b7f6b26c 100644 --- a/auto-generated/gnu-api-tests/vlseg8e16ff.c +++ b/auto-generated/gnu-api-tests/vlseg8e16ff.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf4x8(rs1, new_vl, vl); } -vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf2x8(rs1, new_vl, vl); } -vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8(const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8(const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16m1x8(rs1, new_vl, vl); } @@ -43,15 +43,15 @@ vuint16m1x8_t test_vlseg8e16ff_v_u16m1x8(const uint16_t *rs1, size_t *new_vl, si return __riscv_vlseg8e16ff_v_u16m1x8(rs1, new_vl, vl); } -vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf4x8_m(vm, rs1, new_vl, vl); } -vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf2x8_m(vm, rs1, new_vl, vl); } -vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16m1x8_m(vm, rs1, new_vl, vl); } diff --git a/auto-generated/gnu-api-tests/vlsseg2e16.c b/auto-generated/gnu-api-tests/vlsseg2e16.c index a6f11cb85..91ba7c41f 100644 --- a/auto-generated/gnu-api-tests/vlsseg2e16.c +++ b/auto-generated/gnu-api-tests/vlsseg2e16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m2x2(rs1, rs2, vl); } -vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m4x2(rs1, rs2, vl); } @@ -67,23 +67,23 @@ vuint16m4x2_t test_vlsseg2e16_v_u16m4x2(const uint16_t *rs1, ptrdiff_t rs2, size return __riscv_vlsseg2e16_v_u16m4x2(rs1, rs2, vl); } -vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf4x2_m(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m2x2_m(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m4x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vlsseg3e16.c b/auto-generated/gnu-api-tests/vlsseg3e16.c index dfdcd2147..cacde5b2a 100644 --- a/auto-generated/gnu-api-tests/vlsseg3e16.c +++ b/auto-generated/gnu-api-tests/vlsseg3e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m2x3(rs1, rs2, vl); } @@ -55,19 +55,19 @@ vuint16m2x3_t test_vlsseg3e16_v_u16m2x3(const uint16_t *rs1, ptrdiff_t rs2, size return __riscv_vlsseg3e16_v_u16m2x3(rs1, rs2, vl); } -vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf4x3_m(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vlsseg4e16.c b/auto-generated/gnu-api-tests/vlsseg4e16.c index 038af883e..a726323fc 100644 --- a/auto-generated/gnu-api-tests/vlsseg4e16.c +++ b/auto-generated/gnu-api-tests/vlsseg4e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m2x4(rs1, rs2, vl); } @@ -55,19 +55,19 @@ vuint16m2x4_t test_vlsseg4e16_v_u16m2x4(const uint16_t *rs1, ptrdiff_t rs2, size return __riscv_vlsseg4e16_v_u16m2x4(rs1, rs2, vl); } -vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf4x4_m(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vlsseg5e16.c b/auto-generated/gnu-api-tests/vlsseg5e16.c index 443692978..f45fd4a90 100644 --- a/auto-generated/gnu-api-tests/vlsseg5e16.c +++ b/auto-generated/gnu-api-tests/vlsseg5e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16m1x5(rs1, rs2, vl); } @@ -43,15 +43,15 @@ vuint16m1x5_t test_vlsseg5e16_v_u16m1x5(const uint16_t *rs1, ptrdiff_t rs2, size return __riscv_vlsseg5e16_v_u16m1x5(rs1, rs2, vl); } -vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf4x5_m(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vlsseg6e16.c b/auto-generated/gnu-api-tests/vlsseg6e16.c index 2e5b83ce6..908f9a0f4 100644 --- a/auto-generated/gnu-api-tests/vlsseg6e16.c +++ b/auto-generated/gnu-api-tests/vlsseg6e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16m1x6(rs1, rs2, vl); } @@ -43,15 +43,15 @@ vuint16m1x6_t test_vlsseg6e16_v_u16m1x6(const uint16_t *rs1, ptrdiff_t rs2, size return __riscv_vlsseg6e16_v_u16m1x6(rs1, rs2, vl); } -vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf4x6_m(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vlsseg7e16.c b/auto-generated/gnu-api-tests/vlsseg7e16.c index 789d7f5f6..005cb7aa7 100644 --- a/auto-generated/gnu-api-tests/vlsseg7e16.c +++ b/auto-generated/gnu-api-tests/vlsseg7e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16m1x7(rs1, rs2, vl); } @@ -43,15 +43,15 @@ vuint16m1x7_t test_vlsseg7e16_v_u16m1x7(const uint16_t *rs1, ptrdiff_t rs2, size return __riscv_vlsseg7e16_v_u16m1x7(rs1, rs2, vl); } -vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf4x7_m(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vlsseg8e16.c b/auto-generated/gnu-api-tests/vlsseg8e16.c index af633a071..893463327 100644 --- a/auto-generated/gnu-api-tests/vlsseg8e16.c +++ b/auto-generated/gnu-api-tests/vlsseg8e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8(const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8(const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16m1x8(rs1, rs2, vl); } @@ -43,15 +43,15 @@ vuint16m1x8_t test_vlsseg8e16_v_u16m1x8(const uint16_t *rs1, ptrdiff_t rs2, size return __riscv_vlsseg8e16_v_u16m1x8(rs1, rs2, vl); } -vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf4x8_m(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxei16.c b/auto-generated/gnu-api-tests/vluxei16.c index 8bb03ce85..e6a8a92f2 100644 --- a/auto-generated/gnu-api-tests/vluxei16.c +++ b/auto-generated/gnu-api-tests/vluxei16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei16_v_f16mf4(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei16_v_f16mf4(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei16_v_f16mf2(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vluxei16_v_f16m1(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2(const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vluxei16_v_f16m2(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m2(rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4(const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vluxei16_v_f16m4(const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m4(rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8(const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vluxei16_v_f16m8(const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m8(rs1, rs2, vl); } @@ -235,27 +235,27 @@ vuint64m8_t test_vluxei16_v_u64m8(const uint64_t *rs1, vuint16m2_t rs2, size_t v return __riscv_vluxei16_v_u64m8(rs1, rs2, vl); } -vfloat16mf4_t test_vluxei16_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei16_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei16_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vluxei16_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2_m(vbool8_t vm, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vluxei16_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m2_m(vm, rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4_m(vbool4_t vm, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vluxei16_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m4_m(vm, rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8_m(vbool2_t vm, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vluxei16_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxei32.c b/auto-generated/gnu-api-tests/vluxei32.c index a4d158bf2..60db65667 100644 --- a/auto-generated/gnu-api-tests/vluxei32.c +++ b/auto-generated/gnu-api-tests/vluxei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei32_v_f16mf4(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei32_v_f16mf4(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei32_v_f16mf2(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei32_v_f16m1(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2(const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vluxei32_v_f16m2(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m2(rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4(const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vluxei32_v_f16m4(const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m4(rs1, rs2, vl); } @@ -215,23 +215,23 @@ vuint64m8_t test_vluxei32_v_u64m8(const uint64_t *rs1, vuint32m4_t rs2, size_t v return __riscv_vluxei32_v_u64m8(rs1, rs2, vl); } -vfloat16mf4_t test_vluxei32_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei32_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei32_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei32_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2_m(vbool8_t vm, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vluxei32_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m2_m(vm, rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4_m(vbool4_t vm, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vluxei32_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxei64.c b/auto-generated/gnu-api-tests/vluxei64.c index 8e96e5f87..d2ebacfe8 100644 --- a/auto-generated/gnu-api-tests/vluxei64.c +++ b/auto-generated/gnu-api-tests/vluxei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei64_v_f16mf4(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei64_v_f16mf4(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei64_v_f16mf2(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vluxei64_v_f16m1(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2(const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vluxei64_v_f16m2(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m2(rs1, rs2, vl); } @@ -183,19 +183,19 @@ vuint64m8_t test_vluxei64_v_u64m8(const uint64_t *rs1, vuint64m8_t rs2, size_t v return __riscv_vluxei64_v_u64m8(rs1, rs2, vl); } -vfloat16mf4_t test_vluxei64_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei64_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei64_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vluxei64_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2_m(vbool8_t vm, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vluxei64_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxei8.c b/auto-generated/gnu-api-tests/vluxei8.c index e019c8fa6..a8544cdd9 100644 --- a/auto-generated/gnu-api-tests/vluxei8.c +++ b/auto-generated/gnu-api-tests/vluxei8.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei8_v_f16mf4(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei8_v_f16mf4(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf4(rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei8_v_f16mf2(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf2(rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei8_v_f16m1(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m1(rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2(const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vluxei8_v_f16m2(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m2(rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4(const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vluxei8_v_f16m4(const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m4(rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8(const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vluxei8_v_f16m8(const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m8(rs1, rs2, vl); } @@ -243,27 +243,27 @@ vuint64m8_t test_vluxei8_v_u64m8(const uint64_t *rs1, vuint8m1_t rs2, size_t vl) return __riscv_vluxei8_v_u64m8(rs1, rs2, vl); } -vfloat16mf4_t test_vluxei8_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei8_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf4_m(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei8_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf2_m(vm, rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei8_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m1_m(vm, rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2_m(vbool8_t vm, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vluxei8_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m2_m(vm, rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4_m(vbool4_t vm, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vluxei8_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m4_m(vm, rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8_m(vbool2_t vm, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vluxei8_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg2ei16.c b/auto-generated/gnu-api-tests/vluxseg2ei16.c index 668c0cc3d..5b58d89e8 100644 --- a/auto-generated/gnu-api-tests/vluxseg2ei16.c +++ b/auto-generated/gnu-api-tests/vluxseg2ei16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2(const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m2x2(rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2(const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2(const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m4x2(rs1, rs2, vl); } @@ -199,23 +199,23 @@ vuint64m4x2_t test_vluxseg2ei16_v_u64m4x2(const uint64_t *rs1, vuint16m1_t rs2, return __riscv_vluxseg2ei16_v_u64m4x2(rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf4x2_m(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m2x2_m(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m4x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg2ei32.c b/auto-generated/gnu-api-tests/vluxseg2ei32.c index edc7c1775..4be91de55 100644 --- a/auto-generated/gnu-api-tests/vluxseg2ei32.c +++ b/auto-generated/gnu-api-tests/vluxseg2ei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2(const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m2x2(rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2(const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2(const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m4x2(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m4x2_t test_vluxseg2ei32_v_u64m4x2(const uint64_t *rs1, vuint32m2_t rs2, return __riscv_vluxseg2ei32_v_u64m4x2(rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf4x2_m(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m2x2_m(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m4x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg2ei64.c b/auto-generated/gnu-api-tests/vluxseg2ei64.c index 564101321..537ec540a 100644 --- a/auto-generated/gnu-api-tests/vluxseg2ei64.c +++ b/auto-generated/gnu-api-tests/vluxseg2ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2(const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m2x2(rs1, rs2, vl); } @@ -171,19 +171,19 @@ vuint64m4x2_t test_vluxseg2ei64_v_u64m4x2(const uint64_t *rs1, vuint64m4_t rs2, return __riscv_vluxseg2ei64_v_u64m4x2(rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf4x2_m(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m2x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg2ei8.c b/auto-generated/gnu-api-tests/vluxseg2ei8.c index b5520f349..eb81dd7af 100644 --- a/auto-generated/gnu-api-tests/vluxseg2ei8.c +++ b/auto-generated/gnu-api-tests/vluxseg2ei8.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf4x2(rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf2x2(rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m1x2(rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2(const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m2x2(rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2(const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2(const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m4x2(rs1, rs2, vl); } @@ -199,23 +199,23 @@ vuint64m4x2_t test_vluxseg2ei8_v_u64m4x2(const uint64_t *rs1, vuint8mf2_t rs2, s return __riscv_vluxseg2ei8_v_u64m4x2(rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf4x2_m(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf2x2_m(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m1x2_m(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m2x2_m(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m4x2_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg3ei16.c b/auto-generated/gnu-api-tests/vluxseg3ei16.c index 10405f6bd..7503dcb3b 100644 --- a/auto-generated/gnu-api-tests/vluxseg3ei16.c +++ b/auto-generated/gnu-api-tests/vluxseg3ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3(const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m2x3(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vluxseg3ei16_v_u64m2x3(const uint64_t *rs1, vuint16mf2_t rs2, return __riscv_vluxseg3ei16_v_u64m2x3(rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf4x3_m(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg3ei32.c b/auto-generated/gnu-api-tests/vluxseg3ei32.c index 007ea8dee..1e3a4cb1a 100644 --- a/auto-generated/gnu-api-tests/vluxseg3ei32.c +++ b/auto-generated/gnu-api-tests/vluxseg3ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3(const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m2x3(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vluxseg3ei32_v_u64m2x3(const uint64_t *rs1, vuint32m1_t rs2, return __riscv_vluxseg3ei32_v_u64m2x3(rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf4x3_m(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg3ei64.c b/auto-generated/gnu-api-tests/vluxseg3ei64.c index f39a43fe3..28d09e820 100644 --- a/auto-generated/gnu-api-tests/vluxseg3ei64.c +++ b/auto-generated/gnu-api-tests/vluxseg3ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3(const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m2x3(rs1, rs2, vl); } @@ -147,19 +147,19 @@ vuint64m2x3_t test_vluxseg3ei64_v_u64m2x3(const uint64_t *rs1, vuint64m2_t rs2, return __riscv_vluxseg3ei64_v_u64m2x3(rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf4x3_m(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg3ei8.c b/auto-generated/gnu-api-tests/vluxseg3ei8.c index 0603f7704..65e9d82d6 100644 --- a/auto-generated/gnu-api-tests/vluxseg3ei8.c +++ b/auto-generated/gnu-api-tests/vluxseg3ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf4x3(rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf2x3(rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m1x3(rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3(const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m2x3(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vluxseg3ei8_v_u64m2x3(const uint64_t *rs1, vuint8mf4_t rs2, s return __riscv_vluxseg3ei8_v_u64m2x3(rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf4x3_m(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf2x3_m(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m1x3_m(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m2x3_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg4ei16.c b/auto-generated/gnu-api-tests/vluxseg4ei16.c index 8a4c3cd53..385bfedb9 100644 --- a/auto-generated/gnu-api-tests/vluxseg4ei16.c +++ b/auto-generated/gnu-api-tests/vluxseg4ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4(const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m2x4(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vluxseg4ei16_v_u64m2x4(const uint64_t *rs1, vuint16mf2_t rs2, return __riscv_vluxseg4ei16_v_u64m2x4(rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf4x4_m(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg4ei32.c b/auto-generated/gnu-api-tests/vluxseg4ei32.c index 02fa507b4..87e7eb37a 100644 --- a/auto-generated/gnu-api-tests/vluxseg4ei32.c +++ b/auto-generated/gnu-api-tests/vluxseg4ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4(const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m2x4(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vluxseg4ei32_v_u64m2x4(const uint64_t *rs1, vuint32m1_t rs2, return __riscv_vluxseg4ei32_v_u64m2x4(rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf4x4_m(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg4ei64.c b/auto-generated/gnu-api-tests/vluxseg4ei64.c index 981492b57..e28c1a335 100644 --- a/auto-generated/gnu-api-tests/vluxseg4ei64.c +++ b/auto-generated/gnu-api-tests/vluxseg4ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4(const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m2x4(rs1, rs2, vl); } @@ -147,19 +147,19 @@ vuint64m2x4_t test_vluxseg4ei64_v_u64m2x4(const uint64_t *rs1, vuint64m2_t rs2, return __riscv_vluxseg4ei64_v_u64m2x4(rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf4x4_m(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg4ei8.c b/auto-generated/gnu-api-tests/vluxseg4ei8.c index dfa6fa95c..8ff4209cd 100644 --- a/auto-generated/gnu-api-tests/vluxseg4ei8.c +++ b/auto-generated/gnu-api-tests/vluxseg4ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf4x4(rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf2x4(rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m1x4(rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4(const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m2x4(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vluxseg4ei8_v_u64m2x4(const uint64_t *rs1, vuint8mf4_t rs2, s return __riscv_vluxseg4ei8_v_u64m2x4(rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf4x4_m(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf2x4_m(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m1x4_m(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m2x4_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg5ei16.c b/auto-generated/gnu-api-tests/vluxseg5ei16.c index 0b0b9a51e..5a2e59205 100644 --- a/auto-generated/gnu-api-tests/vluxseg5ei16.c +++ b/auto-generated/gnu-api-tests/vluxseg5ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16m1x5(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vluxseg5ei16_v_u64m1x5(const uint64_t *rs1, vuint16mf4_t rs2, return __riscv_vluxseg5ei16_v_u64m1x5(rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf4x5_m(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg5ei32.c b/auto-generated/gnu-api-tests/vluxseg5ei32.c index 46d9b48d2..936aa9055 100644 --- a/auto-generated/gnu-api-tests/vluxseg5ei32.c +++ b/auto-generated/gnu-api-tests/vluxseg5ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16m1x5(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vluxseg5ei32_v_u64m1x5(const uint64_t *rs1, vuint32mf2_t rs2, return __riscv_vluxseg5ei32_v_u64m1x5(rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf4x5_m(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg5ei64.c b/auto-generated/gnu-api-tests/vluxseg5ei64.c index beb77ab6a..61501df44 100644 --- a/auto-generated/gnu-api-tests/vluxseg5ei64.c +++ b/auto-generated/gnu-api-tests/vluxseg5ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16m1x5(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vluxseg5ei64_v_u64m1x5(const uint64_t *rs1, vuint64m1_t rs2, return __riscv_vluxseg5ei64_v_u64m1x5(rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf4x5_m(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg5ei8.c b/auto-generated/gnu-api-tests/vluxseg5ei8.c index 1cfaf1dd2..26fe6a8dc 100644 --- a/auto-generated/gnu-api-tests/vluxseg5ei8.c +++ b/auto-generated/gnu-api-tests/vluxseg5ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf4x5(rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf2x5(rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16m1x5(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vluxseg5ei8_v_u64m1x5(const uint64_t *rs1, vuint8mf8_t rs2, s return __riscv_vluxseg5ei8_v_u64m1x5(rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf4x5_m(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf2x5_m(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16m1x5_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg6ei16.c b/auto-generated/gnu-api-tests/vluxseg6ei16.c index f39ccb713..984c3c432 100644 --- a/auto-generated/gnu-api-tests/vluxseg6ei16.c +++ b/auto-generated/gnu-api-tests/vluxseg6ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16m1x6(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vluxseg6ei16_v_u64m1x6(const uint64_t *rs1, vuint16mf4_t rs2, return __riscv_vluxseg6ei16_v_u64m1x6(rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf4x6_m(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg6ei32.c b/auto-generated/gnu-api-tests/vluxseg6ei32.c index 27b7416d6..b732a6f0c 100644 --- a/auto-generated/gnu-api-tests/vluxseg6ei32.c +++ b/auto-generated/gnu-api-tests/vluxseg6ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16m1x6(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vluxseg6ei32_v_u64m1x6(const uint64_t *rs1, vuint32mf2_t rs2, return __riscv_vluxseg6ei32_v_u64m1x6(rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf4x6_m(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg6ei64.c b/auto-generated/gnu-api-tests/vluxseg6ei64.c index 3a213200a..ba37b897c 100644 --- a/auto-generated/gnu-api-tests/vluxseg6ei64.c +++ b/auto-generated/gnu-api-tests/vluxseg6ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16m1x6(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vluxseg6ei64_v_u64m1x6(const uint64_t *rs1, vuint64m1_t rs2, return __riscv_vluxseg6ei64_v_u64m1x6(rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf4x6_m(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg6ei8.c b/auto-generated/gnu-api-tests/vluxseg6ei8.c index 8b546a140..b7658854b 100644 --- a/auto-generated/gnu-api-tests/vluxseg6ei8.c +++ b/auto-generated/gnu-api-tests/vluxseg6ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf4x6(rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf2x6(rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16m1x6(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vluxseg6ei8_v_u64m1x6(const uint64_t *rs1, vuint8mf8_t rs2, s return __riscv_vluxseg6ei8_v_u64m1x6(rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf4x6_m(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf2x6_m(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16m1x6_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg7ei16.c b/auto-generated/gnu-api-tests/vluxseg7ei16.c index c9b6ed8e1..71827945e 100644 --- a/auto-generated/gnu-api-tests/vluxseg7ei16.c +++ b/auto-generated/gnu-api-tests/vluxseg7ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16m1x7(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vluxseg7ei16_v_u64m1x7(const uint64_t *rs1, vuint16mf4_t rs2, return __riscv_vluxseg7ei16_v_u64m1x7(rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf4x7_m(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg7ei32.c b/auto-generated/gnu-api-tests/vluxseg7ei32.c index 643d3f9b6..ea4b865bf 100644 --- a/auto-generated/gnu-api-tests/vluxseg7ei32.c +++ b/auto-generated/gnu-api-tests/vluxseg7ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16m1x7(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vluxseg7ei32_v_u64m1x7(const uint64_t *rs1, vuint32mf2_t rs2, return __riscv_vluxseg7ei32_v_u64m1x7(rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf4x7_m(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg7ei64.c b/auto-generated/gnu-api-tests/vluxseg7ei64.c index 06d8bdeb0..fa74dbc7b 100644 --- a/auto-generated/gnu-api-tests/vluxseg7ei64.c +++ b/auto-generated/gnu-api-tests/vluxseg7ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16m1x7(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vluxseg7ei64_v_u64m1x7(const uint64_t *rs1, vuint64m1_t rs2, return __riscv_vluxseg7ei64_v_u64m1x7(rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf4x7_m(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg7ei8.c b/auto-generated/gnu-api-tests/vluxseg7ei8.c index 0dded4723..1cf8e3cb4 100644 --- a/auto-generated/gnu-api-tests/vluxseg7ei8.c +++ b/auto-generated/gnu-api-tests/vluxseg7ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf4x7(rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf2x7(rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16m1x7(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vluxseg7ei8_v_u64m1x7(const uint64_t *rs1, vuint8mf8_t rs2, s return __riscv_vluxseg7ei8_v_u64m1x7(rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf4x7_m(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf2x7_m(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16m1x7_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg8ei16.c b/auto-generated/gnu-api-tests/vluxseg8ei16.c index 715e782d5..a06c72f15 100644 --- a/auto-generated/gnu-api-tests/vluxseg8ei16.c +++ b/auto-generated/gnu-api-tests/vluxseg8ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16m1x8(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vluxseg8ei16_v_u64m1x8(const uint64_t *rs1, vuint16mf4_t rs2, return __riscv_vluxseg8ei16_v_u64m1x8(rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf4x8_m(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg8ei32.c b/auto-generated/gnu-api-tests/vluxseg8ei32.c index 75f4d11b2..9f7577b9e 100644 --- a/auto-generated/gnu-api-tests/vluxseg8ei32.c +++ b/auto-generated/gnu-api-tests/vluxseg8ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16m1x8(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vluxseg8ei32_v_u64m1x8(const uint64_t *rs1, vuint32mf2_t rs2, return __riscv_vluxseg8ei32_v_u64m1x8(rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf4x8_m(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg8ei64.c b/auto-generated/gnu-api-tests/vluxseg8ei64.c index f2dcbfaf9..84e816f05 100644 --- a/auto-generated/gnu-api-tests/vluxseg8ei64.c +++ b/auto-generated/gnu-api-tests/vluxseg8ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16m1x8(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vluxseg8ei64_v_u64m1x8(const uint64_t *rs1, vuint64m1_t rs2, return __riscv_vluxseg8ei64_v_u64m1x8(rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf4x8_m(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vluxseg8ei8.c b/auto-generated/gnu-api-tests/vluxseg8ei8.c index 8d8fbf550..2131a8db8 100644 --- a/auto-generated/gnu-api-tests/vluxseg8ei8.c +++ b/auto-generated/gnu-api-tests/vluxseg8ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf4x8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf2x8(rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16m1x8(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vluxseg8ei8_v_u64m1x8(const uint64_t *rs1, vuint8mf8_t rs2, s return __riscv_vluxseg8ei8_v_u64m1x8(rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf4x8_m(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf2x8_m(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16m1x8_m(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-api-tests/vse16.c b/auto-generated/gnu-api-tests/vse16.c index 832d073fe..75f834d26 100644 --- a/auto-generated/gnu-api-tests/vse16.c +++ b/auto-generated/gnu-api-tests/vse16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vse16_v_f16mf4(float16_t *rs1, vfloat16mf4_t vs3, size_t vl) { +void test_vse16_v_f16mf4(_Float16 *rs1, vfloat16mf4_t vs3, size_t vl) { return __riscv_vse16_v_f16mf4(rs1, vs3, vl); } -void test_vse16_v_f16mf2(float16_t *rs1, vfloat16mf2_t vs3, size_t vl) { +void test_vse16_v_f16mf2(_Float16 *rs1, vfloat16mf2_t vs3, size_t vl) { return __riscv_vse16_v_f16mf2(rs1, vs3, vl); } -void test_vse16_v_f16m1(float16_t *rs1, vfloat16m1_t vs3, size_t vl) { +void test_vse16_v_f16m1(_Float16 *rs1, vfloat16m1_t vs3, size_t vl) { return __riscv_vse16_v_f16m1(rs1, vs3, vl); } -void test_vse16_v_f16m2(float16_t *rs1, vfloat16m2_t vs3, size_t vl) { +void test_vse16_v_f16m2(_Float16 *rs1, vfloat16m2_t vs3, size_t vl) { return __riscv_vse16_v_f16m2(rs1, vs3, vl); } -void test_vse16_v_f16m4(float16_t *rs1, vfloat16m4_t vs3, size_t vl) { +void test_vse16_v_f16m4(_Float16 *rs1, vfloat16m4_t vs3, size_t vl) { return __riscv_vse16_v_f16m4(rs1, vs3, vl); } -void test_vse16_v_f16m8(float16_t *rs1, vfloat16m8_t vs3, size_t vl) { +void test_vse16_v_f16m8(_Float16 *rs1, vfloat16m8_t vs3, size_t vl) { return __riscv_vse16_v_f16m8(rs1, vs3, vl); } @@ -79,27 +79,27 @@ void test_vse16_v_u16m8(uint16_t *rs1, vuint16m8_t vs3, size_t vl) { return __riscv_vse16_v_u16m8(rs1, vs3, vl); } -void test_vse16_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vfloat16mf4_t vs3, size_t vl) { +void test_vse16_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4_t vs3, size_t vl) { return __riscv_vse16_v_f16mf4_m(vm, rs1, vs3, vl); } -void test_vse16_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vfloat16mf2_t vs3, size_t vl) { +void test_vse16_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2_t vs3, size_t vl) { return __riscv_vse16_v_f16mf2_m(vm, rs1, vs3, vl); } -void test_vse16_v_f16m1_m(vbool16_t vm, float16_t *rs1, vfloat16m1_t vs3, size_t vl) { +void test_vse16_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vfloat16m1_t vs3, size_t vl) { return __riscv_vse16_v_f16m1_m(vm, rs1, vs3, vl); } -void test_vse16_v_f16m2_m(vbool8_t vm, float16_t *rs1, vfloat16m2_t vs3, size_t vl) { +void test_vse16_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vfloat16m2_t vs3, size_t vl) { return __riscv_vse16_v_f16m2_m(vm, rs1, vs3, vl); } -void test_vse16_v_f16m4_m(vbool4_t vm, float16_t *rs1, vfloat16m4_t vs3, size_t vl) { +void test_vse16_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vfloat16m4_t vs3, size_t vl) { return __riscv_vse16_v_f16m4_m(vm, rs1, vs3, vl); } -void test_vse16_v_f16m8_m(vbool2_t vm, float16_t *rs1, vfloat16m8_t vs3, size_t vl) { +void test_vse16_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vfloat16m8_t vs3, size_t vl) { return __riscv_vse16_v_f16m8_m(vm, rs1, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxei16.c b/auto-generated/gnu-api-tests/vsoxei16.c index a80893b60..5c5e41418 100644 --- a/auto-generated/gnu-api-tests/vsoxei16.c +++ b/auto-generated/gnu-api-tests/vsoxei16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxei16_v_f16mf4(float16_t *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsoxei16_v_f16mf4(_Float16 *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16mf2(float16_t *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsoxei16_v_f16mf2(_Float16 *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m1(float16_t *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsoxei16_v_f16m1(_Float16 *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m2(float16_t *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsoxei16_v_f16m2(_Float16 *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16m2(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m4(float16_t *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsoxei16_v_f16m4(_Float16 *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16m4(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m8(float16_t *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsoxei16_v_f16m8(_Float16 *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16m8(rs1, rs2, vs3, vl); } @@ -235,27 +235,27 @@ void test_vsoxei16_v_u64m8(uint64_t *rs1, vuint16m2_t rs2, vuint64m8_t vs3, size return __riscv_vsoxei16_v_u64m8(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsoxei16_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsoxei16_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsoxei16_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsoxei16_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16m2_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsoxei16_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16m4_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m8_m(vbool2_t vm, float16_t *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsoxei16_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsoxei16_v_f16m8_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxei32.c b/auto-generated/gnu-api-tests/vsoxei32.c index e10f41aa2..3167dd6c7 100644 --- a/auto-generated/gnu-api-tests/vsoxei32.c +++ b/auto-generated/gnu-api-tests/vsoxei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxei32_v_f16mf4(float16_t *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsoxei32_v_f16mf4(_Float16 *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16mf2(float16_t *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsoxei32_v_f16mf2(_Float16 *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m1(float16_t *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsoxei32_v_f16m1(_Float16 *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m2(float16_t *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsoxei32_v_f16m2(_Float16 *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16m2(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m4(float16_t *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsoxei32_v_f16m4(_Float16 *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16m4(rs1, rs2, vs3, vl); } @@ -215,23 +215,23 @@ void test_vsoxei32_v_u64m8(uint64_t *rs1, vuint32m4_t rs2, vuint64m8_t vs3, size return __riscv_vsoxei32_v_u64m8(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsoxei32_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsoxei32_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsoxei32_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsoxei32_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16m2_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsoxei32_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei32_v_f16m4_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxei64.c b/auto-generated/gnu-api-tests/vsoxei64.c index c5d3df263..cf61680dc 100644 --- a/auto-generated/gnu-api-tests/vsoxei64.c +++ b/auto-generated/gnu-api-tests/vsoxei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxei64_v_f16mf4(float16_t *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsoxei64_v_f16mf4(_Float16 *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei64_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16mf2(float16_t *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsoxei64_v_f16mf2(_Float16 *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei64_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16m1(float16_t *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsoxei64_v_f16m1(_Float16 *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei64_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16m2(float16_t *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsoxei64_v_f16m2(_Float16 *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei64_v_f16m2(rs1, rs2, vs3, vl); } @@ -183,19 +183,19 @@ void test_vsoxei64_v_u64m8(uint64_t *rs1, vuint64m8_t rs2, vuint64m8_t vs3, size return __riscv_vsoxei64_v_u64m8(rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsoxei64_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei64_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsoxei64_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei64_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsoxei64_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei64_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsoxei64_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei64_v_f16m2_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxei8.c b/auto-generated/gnu-api-tests/vsoxei8.c index 5ff0e5851..23e6e4a19 100644 --- a/auto-generated/gnu-api-tests/vsoxei8.c +++ b/auto-generated/gnu-api-tests/vsoxei8.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxei8_v_f16mf4(float16_t *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsoxei8_v_f16mf4(_Float16 *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16mf2(float16_t *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsoxei8_v_f16mf2(_Float16 *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m1(float16_t *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsoxei8_v_f16m1(_Float16 *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m2(float16_t *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsoxei8_v_f16m2(_Float16 *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16m2(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m4(float16_t *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsoxei8_v_f16m4(_Float16 *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16m4(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m8(float16_t *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsoxei8_v_f16m8(_Float16 *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16m8(rs1, rs2, vs3, vl); } @@ -243,27 +243,27 @@ void test_vsoxei8_v_u64m8(uint64_t *rs1, vuint8m1_t rs2, vuint64m8_t vs3, size_t return __riscv_vsoxei8_v_u64m8(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsoxei8_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsoxei8_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsoxei8_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsoxei8_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16m2_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsoxei8_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16m4_m(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m8_m(vbool2_t vm, float16_t *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsoxei8_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsoxei8_v_f16m8_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg2ei16.c b/auto-generated/gnu-api-tests/vsoxseg2ei16.c index 37b921da6..e8e0c7a65 100644 --- a/auto-generated/gnu-api-tests/vsoxseg2ei16.c +++ b/auto-generated/gnu-api-tests/vsoxseg2ei16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg2ei16_v_f16mf4x2(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16mf4x2(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16mf4x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16mf2x2(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16mf2x2(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16mf2x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m1x2(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16m1x2(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16m1x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m2x2(float16_t *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16m2x2(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16m2x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m4x2(float16_t *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16m4x2(_Float16 *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16m4x2(rs1, vs2, vs3, vl); } @@ -199,23 +199,23 @@ void test_vsoxseg2ei16_v_u64m4x2(uint64_t *rs1, vuint16m1_t vs2, vuint64m4x2_t v return __riscv_vsoxseg2ei16_v_u64m4x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16mf4x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16mf2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16m1x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16m2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16_v_f16m4x2_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg2ei32.c b/auto-generated/gnu-api-tests/vsoxseg2ei32.c index bb8ec819c..8271bfcd4 100644 --- a/auto-generated/gnu-api-tests/vsoxseg2ei32.c +++ b/auto-generated/gnu-api-tests/vsoxseg2ei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg2ei32_v_f16mf4x2(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16mf4x2(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16mf4x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16mf2x2(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16mf2x2(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16mf2x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m1x2(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16m1x2(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16m1x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m2x2(float16_t *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16m2x2(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16m2x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m4x2(float16_t *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16m4x2(_Float16 *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16m4x2(rs1, vs2, vs3, vl); } @@ -191,23 +191,23 @@ void test_vsoxseg2ei32_v_u64m4x2(uint64_t *rs1, vuint32m2_t vs2, vuint64m4x2_t v return __riscv_vsoxseg2ei32_v_u64m4x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16mf4x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16mf2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16m1x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16m2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32_v_f16m4x2_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg2ei64.c b/auto-generated/gnu-api-tests/vsoxseg2ei64.c index 542de748c..c26646b78 100644 --- a/auto-generated/gnu-api-tests/vsoxseg2ei64.c +++ b/auto-generated/gnu-api-tests/vsoxseg2ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg2ei64_v_f16mf4x2(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsoxseg2ei64_v_f16mf4x2(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64_v_f16mf4x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16mf2x2(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsoxseg2ei64_v_f16mf2x2(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64_v_f16mf2x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16m1x2(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsoxseg2ei64_v_f16m1x2(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64_v_f16m1x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16m2x2(float16_t *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsoxseg2ei64_v_f16m2x2(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64_v_f16m2x2(rs1, vs2, vs3, vl); } @@ -171,19 +171,19 @@ void test_vsoxseg2ei64_v_u64m4x2(uint64_t *rs1, vuint64m4_t vs2, vuint64m4x2_t v return __riscv_vsoxseg2ei64_v_u64m4x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsoxseg2ei64_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64_v_f16mf4x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsoxseg2ei64_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64_v_f16mf2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsoxseg2ei64_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64_v_f16m1x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsoxseg2ei64_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64_v_f16m2x2_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg2ei8.c b/auto-generated/gnu-api-tests/vsoxseg2ei8.c index 655f11554..2aab9010d 100644 --- a/auto-generated/gnu-api-tests/vsoxseg2ei8.c +++ b/auto-generated/gnu-api-tests/vsoxseg2ei8.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg2ei8_v_f16mf4x2(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16mf4x2(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16mf4x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16mf2x2(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16mf2x2(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16mf2x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m1x2(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16m1x2(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16m1x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m2x2(float16_t *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16m2x2(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16m2x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m4x2(float16_t *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16m4x2(_Float16 *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16m4x2(rs1, vs2, vs3, vl); } @@ -199,23 +199,23 @@ void test_vsoxseg2ei8_v_u64m4x2(uint64_t *rs1, vuint8mf2_t vs2, vuint64m4x2_t vs return __riscv_vsoxseg2ei8_v_u64m4x2(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16mf4x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16mf2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16m1x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16m2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8_v_f16m4x2_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg3ei16.c b/auto-generated/gnu-api-tests/vsoxseg3ei16.c index f51618b9b..a99b5395d 100644 --- a/auto-generated/gnu-api-tests/vsoxseg3ei16.c +++ b/auto-generated/gnu-api-tests/vsoxseg3ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg3ei16_v_f16mf4x3(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsoxseg3ei16_v_f16mf4x3(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16_v_f16mf4x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16mf2x3(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsoxseg3ei16_v_f16mf2x3(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16_v_f16mf2x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16m1x3(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsoxseg3ei16_v_f16m1x3(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16_v_f16m1x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16m2x3(float16_t *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsoxseg3ei16_v_f16m2x3(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16_v_f16m2x3(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsoxseg3ei16_v_u64m2x3(uint64_t *rs1, vuint16mf2_t vs2, vuint64m2x3_t return __riscv_vsoxseg3ei16_v_u64m2x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsoxseg3ei16_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16_v_f16mf4x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsoxseg3ei16_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16_v_f16mf2x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsoxseg3ei16_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16_v_f16m1x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsoxseg3ei16_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16_v_f16m2x3_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg3ei32.c b/auto-generated/gnu-api-tests/vsoxseg3ei32.c index 2c4c20931..cc8c49a70 100644 --- a/auto-generated/gnu-api-tests/vsoxseg3ei32.c +++ b/auto-generated/gnu-api-tests/vsoxseg3ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg3ei32_v_f16mf4x3(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsoxseg3ei32_v_f16mf4x3(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32_v_f16mf4x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16mf2x3(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsoxseg3ei32_v_f16mf2x3(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32_v_f16mf2x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16m1x3(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsoxseg3ei32_v_f16m1x3(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32_v_f16m1x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16m2x3(float16_t *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsoxseg3ei32_v_f16m2x3(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32_v_f16m2x3(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsoxseg3ei32_v_u64m2x3(uint64_t *rs1, vuint32m1_t vs2, vuint64m2x3_t v return __riscv_vsoxseg3ei32_v_u64m2x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsoxseg3ei32_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32_v_f16mf4x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsoxseg3ei32_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32_v_f16mf2x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsoxseg3ei32_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32_v_f16m1x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsoxseg3ei32_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32_v_f16m2x3_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg3ei64.c b/auto-generated/gnu-api-tests/vsoxseg3ei64.c index 35aa96703..65a5ee6fa 100644 --- a/auto-generated/gnu-api-tests/vsoxseg3ei64.c +++ b/auto-generated/gnu-api-tests/vsoxseg3ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg3ei64_v_f16mf4x3(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsoxseg3ei64_v_f16mf4x3(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64_v_f16mf4x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16mf2x3(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsoxseg3ei64_v_f16mf2x3(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64_v_f16mf2x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16m1x3(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsoxseg3ei64_v_f16m1x3(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64_v_f16m1x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16m2x3(float16_t *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsoxseg3ei64_v_f16m2x3(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64_v_f16m2x3(rs1, vs2, vs3, vl); } @@ -147,19 +147,19 @@ void test_vsoxseg3ei64_v_u64m2x3(uint64_t *rs1, vuint64m2_t vs2, vuint64m2x3_t v return __riscv_vsoxseg3ei64_v_u64m2x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsoxseg3ei64_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64_v_f16mf4x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsoxseg3ei64_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64_v_f16mf2x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsoxseg3ei64_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64_v_f16m1x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsoxseg3ei64_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64_v_f16m2x3_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg3ei8.c b/auto-generated/gnu-api-tests/vsoxseg3ei8.c index e9f600164..51b2036e7 100644 --- a/auto-generated/gnu-api-tests/vsoxseg3ei8.c +++ b/auto-generated/gnu-api-tests/vsoxseg3ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg3ei8_v_f16mf4x3(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsoxseg3ei8_v_f16mf4x3(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8_v_f16mf4x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16mf2x3(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsoxseg3ei8_v_f16mf2x3(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8_v_f16mf2x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16m1x3(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsoxseg3ei8_v_f16m1x3(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8_v_f16m1x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16m2x3(float16_t *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsoxseg3ei8_v_f16m2x3(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8_v_f16m2x3(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsoxseg3ei8_v_u64m2x3(uint64_t *rs1, vuint8mf4_t vs2, vuint64m2x3_t vs return __riscv_vsoxseg3ei8_v_u64m2x3(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsoxseg3ei8_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8_v_f16mf4x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsoxseg3ei8_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8_v_f16mf2x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsoxseg3ei8_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8_v_f16m1x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsoxseg3ei8_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8_v_f16m2x3_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg4ei16.c b/auto-generated/gnu-api-tests/vsoxseg4ei16.c index cb72ca49f..6fcbae2d7 100644 --- a/auto-generated/gnu-api-tests/vsoxseg4ei16.c +++ b/auto-generated/gnu-api-tests/vsoxseg4ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg4ei16_v_f16mf4x4(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsoxseg4ei16_v_f16mf4x4(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16_v_f16mf4x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16mf2x4(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsoxseg4ei16_v_f16mf2x4(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16_v_f16mf2x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16m1x4(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsoxseg4ei16_v_f16m1x4(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16_v_f16m1x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16m2x4(float16_t *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsoxseg4ei16_v_f16m2x4(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16_v_f16m2x4(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsoxseg4ei16_v_u64m2x4(uint64_t *rs1, vuint16mf2_t vs2, vuint64m2x4_t return __riscv_vsoxseg4ei16_v_u64m2x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsoxseg4ei16_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16_v_f16mf4x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsoxseg4ei16_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16_v_f16mf2x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsoxseg4ei16_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16_v_f16m1x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsoxseg4ei16_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16_v_f16m2x4_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg4ei32.c b/auto-generated/gnu-api-tests/vsoxseg4ei32.c index b59576514..7ef40e57a 100644 --- a/auto-generated/gnu-api-tests/vsoxseg4ei32.c +++ b/auto-generated/gnu-api-tests/vsoxseg4ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg4ei32_v_f16mf4x4(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsoxseg4ei32_v_f16mf4x4(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32_v_f16mf4x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16mf2x4(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsoxseg4ei32_v_f16mf2x4(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32_v_f16mf2x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16m1x4(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsoxseg4ei32_v_f16m1x4(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32_v_f16m1x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16m2x4(float16_t *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsoxseg4ei32_v_f16m2x4(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32_v_f16m2x4(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsoxseg4ei32_v_u64m2x4(uint64_t *rs1, vuint32m1_t vs2, vuint64m2x4_t v return __riscv_vsoxseg4ei32_v_u64m2x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsoxseg4ei32_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32_v_f16mf4x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsoxseg4ei32_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32_v_f16mf2x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsoxseg4ei32_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32_v_f16m1x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsoxseg4ei32_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32_v_f16m2x4_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg4ei64.c b/auto-generated/gnu-api-tests/vsoxseg4ei64.c index 8fd7b3a0c..8116dda75 100644 --- a/auto-generated/gnu-api-tests/vsoxseg4ei64.c +++ b/auto-generated/gnu-api-tests/vsoxseg4ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg4ei64_v_f16mf4x4(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsoxseg4ei64_v_f16mf4x4(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64_v_f16mf4x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16mf2x4(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsoxseg4ei64_v_f16mf2x4(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64_v_f16mf2x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16m1x4(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsoxseg4ei64_v_f16m1x4(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64_v_f16m1x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16m2x4(float16_t *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsoxseg4ei64_v_f16m2x4(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64_v_f16m2x4(rs1, vs2, vs3, vl); } @@ -147,19 +147,19 @@ void test_vsoxseg4ei64_v_u64m2x4(uint64_t *rs1, vuint64m2_t vs2, vuint64m2x4_t v return __riscv_vsoxseg4ei64_v_u64m2x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsoxseg4ei64_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64_v_f16mf4x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsoxseg4ei64_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64_v_f16mf2x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsoxseg4ei64_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64_v_f16m1x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsoxseg4ei64_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64_v_f16m2x4_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg4ei8.c b/auto-generated/gnu-api-tests/vsoxseg4ei8.c index 8b2a042ae..bdae2f505 100644 --- a/auto-generated/gnu-api-tests/vsoxseg4ei8.c +++ b/auto-generated/gnu-api-tests/vsoxseg4ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg4ei8_v_f16mf4x4(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsoxseg4ei8_v_f16mf4x4(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8_v_f16mf4x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16mf2x4(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsoxseg4ei8_v_f16mf2x4(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8_v_f16mf2x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16m1x4(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsoxseg4ei8_v_f16m1x4(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8_v_f16m1x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16m2x4(float16_t *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsoxseg4ei8_v_f16m2x4(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8_v_f16m2x4(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsoxseg4ei8_v_u64m2x4(uint64_t *rs1, vuint8mf4_t vs2, vuint64m2x4_t vs return __riscv_vsoxseg4ei8_v_u64m2x4(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsoxseg4ei8_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8_v_f16mf4x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsoxseg4ei8_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8_v_f16mf2x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsoxseg4ei8_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8_v_f16m1x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsoxseg4ei8_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8_v_f16m2x4_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg5ei16.c b/auto-generated/gnu-api-tests/vsoxseg5ei16.c index 317ca8974..bf7122d39 100644 --- a/auto-generated/gnu-api-tests/vsoxseg5ei16.c +++ b/auto-generated/gnu-api-tests/vsoxseg5ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg5ei16_v_f16mf4x5(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsoxseg5ei16_v_f16mf4x5(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16_v_f16mf4x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16mf2x5(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsoxseg5ei16_v_f16mf2x5(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16_v_f16mf2x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16m1x5(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsoxseg5ei16_v_f16m1x5(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16_v_f16m1x5(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg5ei16_v_u64m1x5(uint64_t *rs1, vuint16mf4_t vs2, vuint64m1x5_t return __riscv_vsoxseg5ei16_v_u64m1x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsoxseg5ei16_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16_v_f16mf4x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsoxseg5ei16_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16_v_f16mf2x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsoxseg5ei16_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16_v_f16m1x5_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg5ei32.c b/auto-generated/gnu-api-tests/vsoxseg5ei32.c index e27421fd6..c73b8d370 100644 --- a/auto-generated/gnu-api-tests/vsoxseg5ei32.c +++ b/auto-generated/gnu-api-tests/vsoxseg5ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg5ei32_v_f16mf4x5(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsoxseg5ei32_v_f16mf4x5(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32_v_f16mf4x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16mf2x5(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsoxseg5ei32_v_f16mf2x5(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32_v_f16mf2x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16m1x5(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsoxseg5ei32_v_f16m1x5(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32_v_f16m1x5(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg5ei32_v_u64m1x5(uint64_t *rs1, vuint32mf2_t vs2, vuint64m1x5_t return __riscv_vsoxseg5ei32_v_u64m1x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsoxseg5ei32_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32_v_f16mf4x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsoxseg5ei32_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32_v_f16mf2x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsoxseg5ei32_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32_v_f16m1x5_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg5ei64.c b/auto-generated/gnu-api-tests/vsoxseg5ei64.c index 003520d5a..a1a56924d 100644 --- a/auto-generated/gnu-api-tests/vsoxseg5ei64.c +++ b/auto-generated/gnu-api-tests/vsoxseg5ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg5ei64_v_f16mf4x5(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsoxseg5ei64_v_f16mf4x5(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64_v_f16mf4x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16mf2x5(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsoxseg5ei64_v_f16mf2x5(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64_v_f16mf2x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16m1x5(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsoxseg5ei64_v_f16m1x5(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64_v_f16m1x5(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg5ei64_v_u64m1x5(uint64_t *rs1, vuint64m1_t vs2, vuint64m1x5_t v return __riscv_vsoxseg5ei64_v_u64m1x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsoxseg5ei64_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64_v_f16mf4x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsoxseg5ei64_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64_v_f16mf2x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsoxseg5ei64_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64_v_f16m1x5_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg5ei8.c b/auto-generated/gnu-api-tests/vsoxseg5ei8.c index ef49f382e..e094d9ef0 100644 --- a/auto-generated/gnu-api-tests/vsoxseg5ei8.c +++ b/auto-generated/gnu-api-tests/vsoxseg5ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg5ei8_v_f16mf4x5(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsoxseg5ei8_v_f16mf4x5(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8_v_f16mf4x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16mf2x5(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsoxseg5ei8_v_f16mf2x5(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8_v_f16mf2x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16m1x5(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsoxseg5ei8_v_f16m1x5(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8_v_f16m1x5(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg5ei8_v_u64m1x5(uint64_t *rs1, vuint8mf8_t vs2, vuint64m1x5_t vs return __riscv_vsoxseg5ei8_v_u64m1x5(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsoxseg5ei8_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8_v_f16mf4x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsoxseg5ei8_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8_v_f16mf2x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsoxseg5ei8_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8_v_f16m1x5_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg6ei16.c b/auto-generated/gnu-api-tests/vsoxseg6ei16.c index afbd68d6e..f94c48c45 100644 --- a/auto-generated/gnu-api-tests/vsoxseg6ei16.c +++ b/auto-generated/gnu-api-tests/vsoxseg6ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg6ei16_v_f16mf4x6(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsoxseg6ei16_v_f16mf4x6(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16_v_f16mf4x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16mf2x6(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsoxseg6ei16_v_f16mf2x6(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16_v_f16mf2x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16m1x6(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsoxseg6ei16_v_f16m1x6(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16_v_f16m1x6(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg6ei16_v_u64m1x6(uint64_t *rs1, vuint16mf4_t vs2, vuint64m1x6_t return __riscv_vsoxseg6ei16_v_u64m1x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsoxseg6ei16_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16_v_f16mf4x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsoxseg6ei16_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16_v_f16mf2x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsoxseg6ei16_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16_v_f16m1x6_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg6ei32.c b/auto-generated/gnu-api-tests/vsoxseg6ei32.c index fc138178a..c11e2265d 100644 --- a/auto-generated/gnu-api-tests/vsoxseg6ei32.c +++ b/auto-generated/gnu-api-tests/vsoxseg6ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg6ei32_v_f16mf4x6(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsoxseg6ei32_v_f16mf4x6(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32_v_f16mf4x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16mf2x6(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsoxseg6ei32_v_f16mf2x6(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32_v_f16mf2x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16m1x6(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsoxseg6ei32_v_f16m1x6(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32_v_f16m1x6(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg6ei32_v_u64m1x6(uint64_t *rs1, vuint32mf2_t vs2, vuint64m1x6_t return __riscv_vsoxseg6ei32_v_u64m1x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsoxseg6ei32_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32_v_f16mf4x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsoxseg6ei32_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32_v_f16mf2x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsoxseg6ei32_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32_v_f16m1x6_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg6ei64.c b/auto-generated/gnu-api-tests/vsoxseg6ei64.c index ee4698f9e..bbc7ce09d 100644 --- a/auto-generated/gnu-api-tests/vsoxseg6ei64.c +++ b/auto-generated/gnu-api-tests/vsoxseg6ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg6ei64_v_f16mf4x6(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsoxseg6ei64_v_f16mf4x6(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64_v_f16mf4x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16mf2x6(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsoxseg6ei64_v_f16mf2x6(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64_v_f16mf2x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16m1x6(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsoxseg6ei64_v_f16m1x6(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64_v_f16m1x6(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg6ei64_v_u64m1x6(uint64_t *rs1, vuint64m1_t vs2, vuint64m1x6_t v return __riscv_vsoxseg6ei64_v_u64m1x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsoxseg6ei64_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64_v_f16mf4x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsoxseg6ei64_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64_v_f16mf2x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsoxseg6ei64_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64_v_f16m1x6_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg6ei8.c b/auto-generated/gnu-api-tests/vsoxseg6ei8.c index cb08dfd28..7bc430be7 100644 --- a/auto-generated/gnu-api-tests/vsoxseg6ei8.c +++ b/auto-generated/gnu-api-tests/vsoxseg6ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg6ei8_v_f16mf4x6(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsoxseg6ei8_v_f16mf4x6(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8_v_f16mf4x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16mf2x6(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsoxseg6ei8_v_f16mf2x6(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8_v_f16mf2x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16m1x6(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsoxseg6ei8_v_f16m1x6(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8_v_f16m1x6(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg6ei8_v_u64m1x6(uint64_t *rs1, vuint8mf8_t vs2, vuint64m1x6_t vs return __riscv_vsoxseg6ei8_v_u64m1x6(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsoxseg6ei8_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8_v_f16mf4x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsoxseg6ei8_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8_v_f16mf2x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsoxseg6ei8_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8_v_f16m1x6_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg7ei16.c b/auto-generated/gnu-api-tests/vsoxseg7ei16.c index 50b88de70..1dcca5b5c 100644 --- a/auto-generated/gnu-api-tests/vsoxseg7ei16.c +++ b/auto-generated/gnu-api-tests/vsoxseg7ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg7ei16_v_f16mf4x7(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsoxseg7ei16_v_f16mf4x7(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16_v_f16mf4x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16mf2x7(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsoxseg7ei16_v_f16mf2x7(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16_v_f16mf2x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16m1x7(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsoxseg7ei16_v_f16m1x7(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16_v_f16m1x7(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg7ei16_v_u64m1x7(uint64_t *rs1, vuint16mf4_t vs2, vuint64m1x7_t return __riscv_vsoxseg7ei16_v_u64m1x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsoxseg7ei16_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16_v_f16mf4x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsoxseg7ei16_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16_v_f16mf2x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsoxseg7ei16_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16_v_f16m1x7_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg7ei32.c b/auto-generated/gnu-api-tests/vsoxseg7ei32.c index 51638b8e8..2e2f2b067 100644 --- a/auto-generated/gnu-api-tests/vsoxseg7ei32.c +++ b/auto-generated/gnu-api-tests/vsoxseg7ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg7ei32_v_f16mf4x7(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsoxseg7ei32_v_f16mf4x7(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32_v_f16mf4x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16mf2x7(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsoxseg7ei32_v_f16mf2x7(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32_v_f16mf2x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16m1x7(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsoxseg7ei32_v_f16m1x7(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32_v_f16m1x7(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg7ei32_v_u64m1x7(uint64_t *rs1, vuint32mf2_t vs2, vuint64m1x7_t return __riscv_vsoxseg7ei32_v_u64m1x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsoxseg7ei32_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32_v_f16mf4x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsoxseg7ei32_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32_v_f16mf2x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsoxseg7ei32_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32_v_f16m1x7_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg7ei64.c b/auto-generated/gnu-api-tests/vsoxseg7ei64.c index c24bb846c..03343e537 100644 --- a/auto-generated/gnu-api-tests/vsoxseg7ei64.c +++ b/auto-generated/gnu-api-tests/vsoxseg7ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg7ei64_v_f16mf4x7(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsoxseg7ei64_v_f16mf4x7(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64_v_f16mf4x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16mf2x7(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsoxseg7ei64_v_f16mf2x7(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64_v_f16mf2x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16m1x7(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsoxseg7ei64_v_f16m1x7(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64_v_f16m1x7(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg7ei64_v_u64m1x7(uint64_t *rs1, vuint64m1_t vs2, vuint64m1x7_t v return __riscv_vsoxseg7ei64_v_u64m1x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsoxseg7ei64_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64_v_f16mf4x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsoxseg7ei64_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64_v_f16mf2x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsoxseg7ei64_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64_v_f16m1x7_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg7ei8.c b/auto-generated/gnu-api-tests/vsoxseg7ei8.c index c6e779c79..aaaacafa6 100644 --- a/auto-generated/gnu-api-tests/vsoxseg7ei8.c +++ b/auto-generated/gnu-api-tests/vsoxseg7ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg7ei8_v_f16mf4x7(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsoxseg7ei8_v_f16mf4x7(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8_v_f16mf4x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16mf2x7(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsoxseg7ei8_v_f16mf2x7(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8_v_f16mf2x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16m1x7(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsoxseg7ei8_v_f16m1x7(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8_v_f16m1x7(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg7ei8_v_u64m1x7(uint64_t *rs1, vuint8mf8_t vs2, vuint64m1x7_t vs return __riscv_vsoxseg7ei8_v_u64m1x7(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsoxseg7ei8_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8_v_f16mf4x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsoxseg7ei8_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8_v_f16mf2x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsoxseg7ei8_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8_v_f16m1x7_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg8ei16.c b/auto-generated/gnu-api-tests/vsoxseg8ei16.c index cc1da3cef..7a7e13727 100644 --- a/auto-generated/gnu-api-tests/vsoxseg8ei16.c +++ b/auto-generated/gnu-api-tests/vsoxseg8ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg8ei16_v_f16mf4x8(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsoxseg8ei16_v_f16mf4x8(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16_v_f16mf4x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16mf2x8(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsoxseg8ei16_v_f16mf2x8(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16_v_f16mf2x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16m1x8(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsoxseg8ei16_v_f16m1x8(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16_v_f16m1x8(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg8ei16_v_u64m1x8(uint64_t *rs1, vuint16mf4_t vs2, vuint64m1x8_t return __riscv_vsoxseg8ei16_v_u64m1x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsoxseg8ei16_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16_v_f16mf4x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsoxseg8ei16_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16_v_f16mf2x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsoxseg8ei16_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16_v_f16m1x8_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg8ei32.c b/auto-generated/gnu-api-tests/vsoxseg8ei32.c index cd9b0e427..85f6b8cfb 100644 --- a/auto-generated/gnu-api-tests/vsoxseg8ei32.c +++ b/auto-generated/gnu-api-tests/vsoxseg8ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg8ei32_v_f16mf4x8(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsoxseg8ei32_v_f16mf4x8(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32_v_f16mf4x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16mf2x8(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsoxseg8ei32_v_f16mf2x8(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32_v_f16mf2x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16m1x8(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsoxseg8ei32_v_f16m1x8(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32_v_f16m1x8(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg8ei32_v_u64m1x8(uint64_t *rs1, vuint32mf2_t vs2, vuint64m1x8_t return __riscv_vsoxseg8ei32_v_u64m1x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsoxseg8ei32_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32_v_f16mf4x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsoxseg8ei32_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32_v_f16mf2x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsoxseg8ei32_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32_v_f16m1x8_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg8ei64.c b/auto-generated/gnu-api-tests/vsoxseg8ei64.c index 032fc5bce..c10975fd8 100644 --- a/auto-generated/gnu-api-tests/vsoxseg8ei64.c +++ b/auto-generated/gnu-api-tests/vsoxseg8ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg8ei64_v_f16mf4x8(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsoxseg8ei64_v_f16mf4x8(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64_v_f16mf4x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16mf2x8(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsoxseg8ei64_v_f16mf2x8(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64_v_f16mf2x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16m1x8(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsoxseg8ei64_v_f16m1x8(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64_v_f16m1x8(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg8ei64_v_u64m1x8(uint64_t *rs1, vuint64m1_t vs2, vuint64m1x8_t v return __riscv_vsoxseg8ei64_v_u64m1x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsoxseg8ei64_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64_v_f16mf4x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsoxseg8ei64_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64_v_f16mf2x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsoxseg8ei64_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64_v_f16m1x8_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsoxseg8ei8.c b/auto-generated/gnu-api-tests/vsoxseg8ei8.c index b14f32a40..2e87245f1 100644 --- a/auto-generated/gnu-api-tests/vsoxseg8ei8.c +++ b/auto-generated/gnu-api-tests/vsoxseg8ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg8ei8_v_f16mf4x8(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsoxseg8ei8_v_f16mf4x8(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8_v_f16mf4x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16mf2x8(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsoxseg8ei8_v_f16mf2x8(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8_v_f16mf2x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16m1x8(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsoxseg8ei8_v_f16m1x8(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8_v_f16m1x8(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg8ei8_v_u64m1x8(uint64_t *rs1, vuint8mf8_t vs2, vuint64m1x8_t vs return __riscv_vsoxseg8ei8_v_u64m1x8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsoxseg8ei8_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8_v_f16mf4x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsoxseg8ei8_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8_v_f16mf2x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsoxseg8ei8_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8_v_f16m1x8_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsse16.c b/auto-generated/gnu-api-tests/vsse16.c index d3fc08345..3fe3580c2 100644 --- a/auto-generated/gnu-api-tests/vsse16.c +++ b/auto-generated/gnu-api-tests/vsse16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsse16_v_f16mf4(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsse16_v_f16mf4(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsse16_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16mf2(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsse16_v_f16mf2(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsse16_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m1(float16_t *rs1, ptrdiff_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsse16_v_f16m1(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsse16_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m2(float16_t *rs1, ptrdiff_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsse16_v_f16m2(_Float16 *rs1, ptrdiff_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsse16_v_f16m2(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m4(float16_t *rs1, ptrdiff_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsse16_v_f16m4(_Float16 *rs1, ptrdiff_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsse16_v_f16m4(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m8(float16_t *rs1, ptrdiff_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsse16_v_f16m8(_Float16 *rs1, ptrdiff_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsse16_v_f16m8(rs1, rs2, vs3, vl); } @@ -79,27 +79,27 @@ void test_vsse16_v_u16m8(uint16_t *rs1, ptrdiff_t rs2, vuint16m8_t vs3, size_t v return __riscv_vsse16_v_u16m8(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16mf4_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsse16_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsse16_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16mf2_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsse16_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsse16_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m1_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsse16_v_f16m1_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsse16_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m2_m(vbool8_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsse16_v_f16m2_m(vbool8_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsse16_v_f16m2_m(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m4_m(vbool4_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsse16_v_f16m4_m(vbool4_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsse16_v_f16m4_m(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m8_m(vbool2_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsse16_v_f16m8_m(vbool2_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsse16_v_f16m8_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsseg2e16.c b/auto-generated/gnu-api-tests/vsseg2e16.c index 0cab44f90..fba2b102e 100644 --- a/auto-generated/gnu-api-tests/vsseg2e16.c +++ b/auto-generated/gnu-api-tests/vsseg2e16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg2e16_v_f16mf4x2(float16_t *rs1, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16mf4x2(_Float16 *rs1, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16mf4x2(rs1, vs3, vl); } -void test_vsseg2e16_v_f16mf2x2(float16_t *rs1, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16mf2x2(_Float16 *rs1, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16mf2x2(rs1, vs3, vl); } -void test_vsseg2e16_v_f16m1x2(float16_t *rs1, vfloat16m1x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m1x2(_Float16 *rs1, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16m1x2(rs1, vs3, vl); } -void test_vsseg2e16_v_f16m2x2(float16_t *rs1, vfloat16m2x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m2x2(_Float16 *rs1, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16m2x2(rs1, vs3, vl); } -void test_vsseg2e16_v_f16m4x2(float16_t *rs1, vfloat16m4x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m4x2(_Float16 *rs1, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16m4x2(rs1, vs3, vl); } @@ -67,23 +67,23 @@ void test_vsseg2e16_v_u16m4x2(uint16_t *rs1, vuint16m4x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_u16m4x2(rs1, vs3, vl); } -void test_vsseg2e16_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16mf4x2_m(vm, rs1, vs3, vl); } -void test_vsseg2e16_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16mf2x2_m(vm, rs1, vs3, vl); } -void test_vsseg2e16_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vfloat16m1x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16m1x2_m(vm, rs1, vs3, vl); } -void test_vsseg2e16_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vfloat16m2x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16m2x2_m(vm, rs1, vs3, vl); } -void test_vsseg2e16_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vfloat16m4x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsseg2e16_v_f16m4x2_m(vm, rs1, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsseg3e16.c b/auto-generated/gnu-api-tests/vsseg3e16.c index 88a8a0cfc..5e670216d 100644 --- a/auto-generated/gnu-api-tests/vsseg3e16.c +++ b/auto-generated/gnu-api-tests/vsseg3e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg3e16_v_f16mf4x3(float16_t *rs1, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16mf4x3(_Float16 *rs1, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_f16mf4x3(rs1, vs3, vl); } -void test_vsseg3e16_v_f16mf2x3(float16_t *rs1, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16mf2x3(_Float16 *rs1, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_f16mf2x3(rs1, vs3, vl); } -void test_vsseg3e16_v_f16m1x3(float16_t *rs1, vfloat16m1x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16m1x3(_Float16 *rs1, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_f16m1x3(rs1, vs3, vl); } -void test_vsseg3e16_v_f16m2x3(float16_t *rs1, vfloat16m2x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16m2x3(_Float16 *rs1, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_f16m2x3(rs1, vs3, vl); } @@ -55,19 +55,19 @@ void test_vsseg3e16_v_u16m2x3(uint16_t *rs1, vuint16m2x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_u16m2x3(rs1, vs3, vl); } -void test_vsseg3e16_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_f16mf4x3_m(vm, rs1, vs3, vl); } -void test_vsseg3e16_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_f16mf2x3_m(vm, rs1, vs3, vl); } -void test_vsseg3e16_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vfloat16m1x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_f16m1x3_m(vm, rs1, vs3, vl); } -void test_vsseg3e16_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vfloat16m2x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsseg3e16_v_f16m2x3_m(vm, rs1, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsseg4e16.c b/auto-generated/gnu-api-tests/vsseg4e16.c index 3d559cf34..925be28bb 100644 --- a/auto-generated/gnu-api-tests/vsseg4e16.c +++ b/auto-generated/gnu-api-tests/vsseg4e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg4e16_v_f16mf4x4(float16_t *rs1, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16mf4x4(_Float16 *rs1, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_f16mf4x4(rs1, vs3, vl); } -void test_vsseg4e16_v_f16mf2x4(float16_t *rs1, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16mf2x4(_Float16 *rs1, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_f16mf2x4(rs1, vs3, vl); } -void test_vsseg4e16_v_f16m1x4(float16_t *rs1, vfloat16m1x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16m1x4(_Float16 *rs1, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_f16m1x4(rs1, vs3, vl); } -void test_vsseg4e16_v_f16m2x4(float16_t *rs1, vfloat16m2x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16m2x4(_Float16 *rs1, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_f16m2x4(rs1, vs3, vl); } @@ -55,19 +55,19 @@ void test_vsseg4e16_v_u16m2x4(uint16_t *rs1, vuint16m2x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_u16m2x4(rs1, vs3, vl); } -void test_vsseg4e16_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_f16mf4x4_m(vm, rs1, vs3, vl); } -void test_vsseg4e16_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_f16mf2x4_m(vm, rs1, vs3, vl); } -void test_vsseg4e16_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vfloat16m1x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_f16m1x4_m(vm, rs1, vs3, vl); } -void test_vsseg4e16_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vfloat16m2x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsseg4e16_v_f16m2x4_m(vm, rs1, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsseg5e16.c b/auto-generated/gnu-api-tests/vsseg5e16.c index b6d30fdc4..f3ce6cee0 100644 --- a/auto-generated/gnu-api-tests/vsseg5e16.c +++ b/auto-generated/gnu-api-tests/vsseg5e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg5e16_v_f16mf4x5(float16_t *rs1, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16mf4x5(_Float16 *rs1, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsseg5e16_v_f16mf4x5(rs1, vs3, vl); } -void test_vsseg5e16_v_f16mf2x5(float16_t *rs1, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16mf2x5(_Float16 *rs1, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsseg5e16_v_f16mf2x5(rs1, vs3, vl); } -void test_vsseg5e16_v_f16m1x5(float16_t *rs1, vfloat16m1x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16m1x5(_Float16 *rs1, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsseg5e16_v_f16m1x5(rs1, vs3, vl); } @@ -43,15 +43,15 @@ void test_vsseg5e16_v_u16m1x5(uint16_t *rs1, vuint16m1x5_t vs3, size_t vl) { return __riscv_vsseg5e16_v_u16m1x5(rs1, vs3, vl); } -void test_vsseg5e16_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsseg5e16_v_f16mf4x5_m(vm, rs1, vs3, vl); } -void test_vsseg5e16_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsseg5e16_v_f16mf2x5_m(vm, rs1, vs3, vl); } -void test_vsseg5e16_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vfloat16m1x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsseg5e16_v_f16m1x5_m(vm, rs1, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsseg6e16.c b/auto-generated/gnu-api-tests/vsseg6e16.c index b27ba64cd..14c619493 100644 --- a/auto-generated/gnu-api-tests/vsseg6e16.c +++ b/auto-generated/gnu-api-tests/vsseg6e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg6e16_v_f16mf4x6(float16_t *rs1, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16mf4x6(_Float16 *rs1, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsseg6e16_v_f16mf4x6(rs1, vs3, vl); } -void test_vsseg6e16_v_f16mf2x6(float16_t *rs1, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16mf2x6(_Float16 *rs1, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsseg6e16_v_f16mf2x6(rs1, vs3, vl); } -void test_vsseg6e16_v_f16m1x6(float16_t *rs1, vfloat16m1x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16m1x6(_Float16 *rs1, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsseg6e16_v_f16m1x6(rs1, vs3, vl); } @@ -43,15 +43,15 @@ void test_vsseg6e16_v_u16m1x6(uint16_t *rs1, vuint16m1x6_t vs3, size_t vl) { return __riscv_vsseg6e16_v_u16m1x6(rs1, vs3, vl); } -void test_vsseg6e16_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsseg6e16_v_f16mf4x6_m(vm, rs1, vs3, vl); } -void test_vsseg6e16_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsseg6e16_v_f16mf2x6_m(vm, rs1, vs3, vl); } -void test_vsseg6e16_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vfloat16m1x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsseg6e16_v_f16m1x6_m(vm, rs1, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsseg7e16.c b/auto-generated/gnu-api-tests/vsseg7e16.c index 4add989e1..a401d0ecb 100644 --- a/auto-generated/gnu-api-tests/vsseg7e16.c +++ b/auto-generated/gnu-api-tests/vsseg7e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg7e16_v_f16mf4x7(float16_t *rs1, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16mf4x7(_Float16 *rs1, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsseg7e16_v_f16mf4x7(rs1, vs3, vl); } -void test_vsseg7e16_v_f16mf2x7(float16_t *rs1, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16mf2x7(_Float16 *rs1, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsseg7e16_v_f16mf2x7(rs1, vs3, vl); } -void test_vsseg7e16_v_f16m1x7(float16_t *rs1, vfloat16m1x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16m1x7(_Float16 *rs1, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsseg7e16_v_f16m1x7(rs1, vs3, vl); } @@ -43,15 +43,15 @@ void test_vsseg7e16_v_u16m1x7(uint16_t *rs1, vuint16m1x7_t vs3, size_t vl) { return __riscv_vsseg7e16_v_u16m1x7(rs1, vs3, vl); } -void test_vsseg7e16_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsseg7e16_v_f16mf4x7_m(vm, rs1, vs3, vl); } -void test_vsseg7e16_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsseg7e16_v_f16mf2x7_m(vm, rs1, vs3, vl); } -void test_vsseg7e16_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vfloat16m1x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsseg7e16_v_f16m1x7_m(vm, rs1, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsseg8e16.c b/auto-generated/gnu-api-tests/vsseg8e16.c index 4fa38b4ef..9b8336b2f 100644 --- a/auto-generated/gnu-api-tests/vsseg8e16.c +++ b/auto-generated/gnu-api-tests/vsseg8e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg8e16_v_f16mf4x8(float16_t *rs1, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16mf4x8(_Float16 *rs1, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsseg8e16_v_f16mf4x8(rs1, vs3, vl); } -void test_vsseg8e16_v_f16mf2x8(float16_t *rs1, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16mf2x8(_Float16 *rs1, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsseg8e16_v_f16mf2x8(rs1, vs3, vl); } -void test_vsseg8e16_v_f16m1x8(float16_t *rs1, vfloat16m1x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16m1x8(_Float16 *rs1, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsseg8e16_v_f16m1x8(rs1, vs3, vl); } @@ -43,15 +43,15 @@ void test_vsseg8e16_v_u16m1x8(uint16_t *rs1, vuint16m1x8_t vs3, size_t vl) { return __riscv_vsseg8e16_v_u16m1x8(rs1, vs3, vl); } -void test_vsseg8e16_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsseg8e16_v_f16mf4x8_m(vm, rs1, vs3, vl); } -void test_vsseg8e16_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsseg8e16_v_f16mf2x8_m(vm, rs1, vs3, vl); } -void test_vsseg8e16_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vfloat16m1x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsseg8e16_v_f16m1x8_m(vm, rs1, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vssseg2e16.c b/auto-generated/gnu-api-tests/vssseg2e16.c index d19a66c6c..d3874f2b7 100644 --- a/auto-generated/gnu-api-tests/vssseg2e16.c +++ b/auto-generated/gnu-api-tests/vssseg2e16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg2e16_v_f16mf4x2(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16mf4x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16mf4x2(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16mf2x2(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16mf2x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16mf2x2(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m1x2(float16_t *rs1, ptrdiff_t rs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m1x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16m1x2(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m2x2(float16_t *rs1, ptrdiff_t rs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m2x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16m2x2(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m4x2(float16_t *rs1, ptrdiff_t rs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m4x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16m4x2(rs1, rs2, vs3, vl); } @@ -67,23 +67,23 @@ void test_vssseg2e16_v_u16m4x2(uint16_t *rs1, ptrdiff_t rs2, vuint16m4x2_t vs3, return __riscv_vssseg2e16_v_u16m4x2(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16mf4x2_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16mf2x2_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16m1x2_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16m2x2_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vssseg2e16_v_f16m4x2_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vssseg3e16.c b/auto-generated/gnu-api-tests/vssseg3e16.c index ad53fe5df..da178f030 100644 --- a/auto-generated/gnu-api-tests/vssseg3e16.c +++ b/auto-generated/gnu-api-tests/vssseg3e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg3e16_v_f16mf4x3(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16mf4x3(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vssseg3e16_v_f16mf4x3(rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16mf2x3(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16mf2x3(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vssseg3e16_v_f16mf2x3(rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16m1x3(float16_t *rs1, ptrdiff_t rs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16m1x3(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vssseg3e16_v_f16m1x3(rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16m2x3(float16_t *rs1, ptrdiff_t rs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16m2x3(_Float16 *rs1, ptrdiff_t rs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vssseg3e16_v_f16m2x3(rs1, rs2, vs3, vl); } @@ -55,19 +55,19 @@ void test_vssseg3e16_v_u16m2x3(uint16_t *rs1, ptrdiff_t rs2, vuint16m2x3_t vs3, return __riscv_vssseg3e16_v_u16m2x3(rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vssseg3e16_v_f16mf4x3_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vssseg3e16_v_f16mf2x3_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vssseg3e16_v_f16m1x3_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vssseg3e16_v_f16m2x3_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vssseg4e16.c b/auto-generated/gnu-api-tests/vssseg4e16.c index 5eb4af0b8..b66550a42 100644 --- a/auto-generated/gnu-api-tests/vssseg4e16.c +++ b/auto-generated/gnu-api-tests/vssseg4e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg4e16_v_f16mf4x4(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16mf4x4(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vssseg4e16_v_f16mf4x4(rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16mf2x4(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16mf2x4(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vssseg4e16_v_f16mf2x4(rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16m1x4(float16_t *rs1, ptrdiff_t rs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16m1x4(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vssseg4e16_v_f16m1x4(rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16m2x4(float16_t *rs1, ptrdiff_t rs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16m2x4(_Float16 *rs1, ptrdiff_t rs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vssseg4e16_v_f16m2x4(rs1, rs2, vs3, vl); } @@ -55,19 +55,19 @@ void test_vssseg4e16_v_u16m2x4(uint16_t *rs1, ptrdiff_t rs2, vuint16m2x4_t vs3, return __riscv_vssseg4e16_v_u16m2x4(rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vssseg4e16_v_f16mf4x4_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vssseg4e16_v_f16mf2x4_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vssseg4e16_v_f16m1x4_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vssseg4e16_v_f16m2x4_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vssseg5e16.c b/auto-generated/gnu-api-tests/vssseg5e16.c index fa135be01..3a03d5f51 100644 --- a/auto-generated/gnu-api-tests/vssseg5e16.c +++ b/auto-generated/gnu-api-tests/vssseg5e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg5e16_v_f16mf4x5(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vssseg5e16_v_f16mf4x5(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vssseg5e16_v_f16mf4x5(rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16mf2x5(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vssseg5e16_v_f16mf2x5(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vssseg5e16_v_f16mf2x5(rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16m1x5(float16_t *rs1, ptrdiff_t rs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vssseg5e16_v_f16m1x5(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vssseg5e16_v_f16m1x5(rs1, rs2, vs3, vl); } @@ -43,15 +43,15 @@ void test_vssseg5e16_v_u16m1x5(uint16_t *rs1, ptrdiff_t rs2, vuint16m1x5_t vs3, return __riscv_vssseg5e16_v_u16m1x5(rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vssseg5e16_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vssseg5e16_v_f16mf4x5_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vssseg5e16_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vssseg5e16_v_f16mf2x5_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vssseg5e16_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vssseg5e16_v_f16m1x5_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vssseg6e16.c b/auto-generated/gnu-api-tests/vssseg6e16.c index fb9509c27..0616efa5a 100644 --- a/auto-generated/gnu-api-tests/vssseg6e16.c +++ b/auto-generated/gnu-api-tests/vssseg6e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg6e16_v_f16mf4x6(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vssseg6e16_v_f16mf4x6(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vssseg6e16_v_f16mf4x6(rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16mf2x6(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vssseg6e16_v_f16mf2x6(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vssseg6e16_v_f16mf2x6(rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16m1x6(float16_t *rs1, ptrdiff_t rs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vssseg6e16_v_f16m1x6(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vssseg6e16_v_f16m1x6(rs1, rs2, vs3, vl); } @@ -43,15 +43,15 @@ void test_vssseg6e16_v_u16m1x6(uint16_t *rs1, ptrdiff_t rs2, vuint16m1x6_t vs3, return __riscv_vssseg6e16_v_u16m1x6(rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vssseg6e16_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vssseg6e16_v_f16mf4x6_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vssseg6e16_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vssseg6e16_v_f16mf2x6_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vssseg6e16_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vssseg6e16_v_f16m1x6_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vssseg7e16.c b/auto-generated/gnu-api-tests/vssseg7e16.c index bafc823b4..8f74650e2 100644 --- a/auto-generated/gnu-api-tests/vssseg7e16.c +++ b/auto-generated/gnu-api-tests/vssseg7e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg7e16_v_f16mf4x7(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vssseg7e16_v_f16mf4x7(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vssseg7e16_v_f16mf4x7(rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16mf2x7(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vssseg7e16_v_f16mf2x7(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vssseg7e16_v_f16mf2x7(rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16m1x7(float16_t *rs1, ptrdiff_t rs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vssseg7e16_v_f16m1x7(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vssseg7e16_v_f16m1x7(rs1, rs2, vs3, vl); } @@ -43,15 +43,15 @@ void test_vssseg7e16_v_u16m1x7(uint16_t *rs1, ptrdiff_t rs2, vuint16m1x7_t vs3, return __riscv_vssseg7e16_v_u16m1x7(rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vssseg7e16_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vssseg7e16_v_f16mf4x7_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vssseg7e16_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vssseg7e16_v_f16mf2x7_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vssseg7e16_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vssseg7e16_v_f16m1x7_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vssseg8e16.c b/auto-generated/gnu-api-tests/vssseg8e16.c index 02d73de04..1cdb772d2 100644 --- a/auto-generated/gnu-api-tests/vssseg8e16.c +++ b/auto-generated/gnu-api-tests/vssseg8e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg8e16_v_f16mf4x8(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vssseg8e16_v_f16mf4x8(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vssseg8e16_v_f16mf4x8(rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16mf2x8(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vssseg8e16_v_f16mf2x8(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vssseg8e16_v_f16mf2x8(rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16m1x8(float16_t *rs1, ptrdiff_t rs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vssseg8e16_v_f16m1x8(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vssseg8e16_v_f16m1x8(rs1, rs2, vs3, vl); } @@ -43,15 +43,15 @@ void test_vssseg8e16_v_u16m1x8(uint16_t *rs1, ptrdiff_t rs2, vuint16m1x8_t vs3, return __riscv_vssseg8e16_v_u16m1x8(rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vssseg8e16_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vssseg8e16_v_f16mf4x8_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vssseg8e16_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vssseg8e16_v_f16mf2x8_m(vm, rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vssseg8e16_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vssseg8e16_v_f16m1x8_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxei16.c b/auto-generated/gnu-api-tests/vsuxei16.c index ccf32c678..c91bb3817 100644 --- a/auto-generated/gnu-api-tests/vsuxei16.c +++ b/auto-generated/gnu-api-tests/vsuxei16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxei16_v_f16mf4(float16_t *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsuxei16_v_f16mf4(_Float16 *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16mf2(float16_t *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsuxei16_v_f16mf2(_Float16 *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m1(float16_t *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsuxei16_v_f16m1(_Float16 *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m2(float16_t *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsuxei16_v_f16m2(_Float16 *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16m2(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m4(float16_t *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsuxei16_v_f16m4(_Float16 *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16m4(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m8(float16_t *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsuxei16_v_f16m8(_Float16 *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16m8(rs1, rs2, vs3, vl); } @@ -235,27 +235,27 @@ void test_vsuxei16_v_u64m8(uint64_t *rs1, vuint16m2_t rs2, vuint64m8_t vs3, size return __riscv_vsuxei16_v_u64m8(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsuxei16_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsuxei16_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsuxei16_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsuxei16_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16m2_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsuxei16_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16m4_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m8_m(vbool2_t vm, float16_t *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsuxei16_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsuxei16_v_f16m8_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxei32.c b/auto-generated/gnu-api-tests/vsuxei32.c index 90dbcd980..bf2722768 100644 --- a/auto-generated/gnu-api-tests/vsuxei32.c +++ b/auto-generated/gnu-api-tests/vsuxei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxei32_v_f16mf4(float16_t *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsuxei32_v_f16mf4(_Float16 *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16mf2(float16_t *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsuxei32_v_f16mf2(_Float16 *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m1(float16_t *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsuxei32_v_f16m1(_Float16 *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m2(float16_t *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsuxei32_v_f16m2(_Float16 *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16m2(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m4(float16_t *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsuxei32_v_f16m4(_Float16 *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16m4(rs1, rs2, vs3, vl); } @@ -215,23 +215,23 @@ void test_vsuxei32_v_u64m8(uint64_t *rs1, vuint32m4_t rs2, vuint64m8_t vs3, size return __riscv_vsuxei32_v_u64m8(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsuxei32_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsuxei32_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsuxei32_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsuxei32_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16m2_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsuxei32_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei32_v_f16m4_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxei64.c b/auto-generated/gnu-api-tests/vsuxei64.c index 1b3702183..22255647b 100644 --- a/auto-generated/gnu-api-tests/vsuxei64.c +++ b/auto-generated/gnu-api-tests/vsuxei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxei64_v_f16mf4(float16_t *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsuxei64_v_f16mf4(_Float16 *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei64_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16mf2(float16_t *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsuxei64_v_f16mf2(_Float16 *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei64_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16m1(float16_t *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsuxei64_v_f16m1(_Float16 *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei64_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16m2(float16_t *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsuxei64_v_f16m2(_Float16 *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei64_v_f16m2(rs1, rs2, vs3, vl); } @@ -183,19 +183,19 @@ void test_vsuxei64_v_u64m8(uint64_t *rs1, vuint64m8_t rs2, vuint64m8_t vs3, size return __riscv_vsuxei64_v_u64m8(rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsuxei64_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei64_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsuxei64_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei64_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsuxei64_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei64_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsuxei64_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei64_v_f16m2_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxei8.c b/auto-generated/gnu-api-tests/vsuxei8.c index df15bddd2..5ef106642 100644 --- a/auto-generated/gnu-api-tests/vsuxei8.c +++ b/auto-generated/gnu-api-tests/vsuxei8.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxei8_v_f16mf4(float16_t *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsuxei8_v_f16mf4(_Float16 *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16mf4(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16mf2(float16_t *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsuxei8_v_f16mf2(_Float16 *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16mf2(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m1(float16_t *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsuxei8_v_f16m1(_Float16 *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16m1(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m2(float16_t *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsuxei8_v_f16m2(_Float16 *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16m2(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m4(float16_t *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsuxei8_v_f16m4(_Float16 *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16m4(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m8(float16_t *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsuxei8_v_f16m8(_Float16 *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16m8(rs1, rs2, vs3, vl); } @@ -243,27 +243,27 @@ void test_vsuxei8_v_u64m8(uint64_t *rs1, vuint8m1_t rs2, vuint64m8_t vs3, size_t return __riscv_vsuxei8_v_u64m8(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsuxei8_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16mf4_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsuxei8_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16mf2_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsuxei8_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16m1_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsuxei8_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16m2_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsuxei8_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16m4_m(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m8_m(vbool2_t vm, float16_t *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsuxei8_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsuxei8_v_f16m8_m(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg2ei16.c b/auto-generated/gnu-api-tests/vsuxseg2ei16.c index dc2034065..506e41557 100644 --- a/auto-generated/gnu-api-tests/vsuxseg2ei16.c +++ b/auto-generated/gnu-api-tests/vsuxseg2ei16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg2ei16_v_f16mf4x2(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16mf4x2(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16mf4x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16mf2x2(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16mf2x2(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16mf2x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m1x2(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16m1x2(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16m1x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m2x2(float16_t *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16m2x2(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16m2x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m4x2(float16_t *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16m4x2(_Float16 *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16m4x2(rs1, vs2, vs3, vl); } @@ -199,23 +199,23 @@ void test_vsuxseg2ei16_v_u64m4x2(uint64_t *rs1, vuint16m1_t vs2, vuint64m4x2_t v return __riscv_vsuxseg2ei16_v_u64m4x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16mf4x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16mf2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16m1x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16m2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16_v_f16m4x2_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg2ei32.c b/auto-generated/gnu-api-tests/vsuxseg2ei32.c index ad524d0e7..c743b705d 100644 --- a/auto-generated/gnu-api-tests/vsuxseg2ei32.c +++ b/auto-generated/gnu-api-tests/vsuxseg2ei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg2ei32_v_f16mf4x2(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16mf4x2(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16mf4x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16mf2x2(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16mf2x2(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16mf2x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m1x2(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16m1x2(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16m1x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m2x2(float16_t *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16m2x2(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16m2x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m4x2(float16_t *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16m4x2(_Float16 *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16m4x2(rs1, vs2, vs3, vl); } @@ -191,23 +191,23 @@ void test_vsuxseg2ei32_v_u64m4x2(uint64_t *rs1, vuint32m2_t vs2, vuint64m4x2_t v return __riscv_vsuxseg2ei32_v_u64m4x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16mf4x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16mf2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16m1x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16m2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32_v_f16m4x2_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg2ei64.c b/auto-generated/gnu-api-tests/vsuxseg2ei64.c index 496760c86..53fb8d9a6 100644 --- a/auto-generated/gnu-api-tests/vsuxseg2ei64.c +++ b/auto-generated/gnu-api-tests/vsuxseg2ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg2ei64_v_f16mf4x2(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsuxseg2ei64_v_f16mf4x2(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64_v_f16mf4x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16mf2x2(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsuxseg2ei64_v_f16mf2x2(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64_v_f16mf2x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16m1x2(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsuxseg2ei64_v_f16m1x2(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64_v_f16m1x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16m2x2(float16_t *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsuxseg2ei64_v_f16m2x2(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64_v_f16m2x2(rs1, vs2, vs3, vl); } @@ -171,19 +171,19 @@ void test_vsuxseg2ei64_v_u64m4x2(uint64_t *rs1, vuint64m4_t vs2, vuint64m4x2_t v return __riscv_vsuxseg2ei64_v_u64m4x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsuxseg2ei64_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64_v_f16mf4x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsuxseg2ei64_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64_v_f16mf2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsuxseg2ei64_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64_v_f16m1x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsuxseg2ei64_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64_v_f16m2x2_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg2ei8.c b/auto-generated/gnu-api-tests/vsuxseg2ei8.c index 42aa4f46e..e2a796d72 100644 --- a/auto-generated/gnu-api-tests/vsuxseg2ei8.c +++ b/auto-generated/gnu-api-tests/vsuxseg2ei8.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg2ei8_v_f16mf4x2(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16mf4x2(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16mf4x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16mf2x2(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16mf2x2(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16mf2x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m1x2(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16m1x2(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16m1x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m2x2(float16_t *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16m2x2(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16m2x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m4x2(float16_t *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16m4x2(_Float16 *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16m4x2(rs1, vs2, vs3, vl); } @@ -199,23 +199,23 @@ void test_vsuxseg2ei8_v_u64m4x2(uint64_t *rs1, vuint8mf2_t vs2, vuint64m4x2_t vs return __riscv_vsuxseg2ei8_v_u64m4x2(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16mf4x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16mf2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16m1x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16m2x2_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8_v_f16m4x2_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg3ei16.c b/auto-generated/gnu-api-tests/vsuxseg3ei16.c index 05dcb86ff..417087312 100644 --- a/auto-generated/gnu-api-tests/vsuxseg3ei16.c +++ b/auto-generated/gnu-api-tests/vsuxseg3ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg3ei16_v_f16mf4x3(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsuxseg3ei16_v_f16mf4x3(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16_v_f16mf4x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16mf2x3(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsuxseg3ei16_v_f16mf2x3(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16_v_f16mf2x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16m1x3(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsuxseg3ei16_v_f16m1x3(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16_v_f16m1x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16m2x3(float16_t *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsuxseg3ei16_v_f16m2x3(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16_v_f16m2x3(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsuxseg3ei16_v_u64m2x3(uint64_t *rs1, vuint16mf2_t vs2, vuint64m2x3_t return __riscv_vsuxseg3ei16_v_u64m2x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsuxseg3ei16_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16_v_f16mf4x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsuxseg3ei16_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16_v_f16mf2x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsuxseg3ei16_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16_v_f16m1x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsuxseg3ei16_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16_v_f16m2x3_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg3ei32.c b/auto-generated/gnu-api-tests/vsuxseg3ei32.c index eab85b3f2..6f531532a 100644 --- a/auto-generated/gnu-api-tests/vsuxseg3ei32.c +++ b/auto-generated/gnu-api-tests/vsuxseg3ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg3ei32_v_f16mf4x3(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsuxseg3ei32_v_f16mf4x3(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32_v_f16mf4x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16mf2x3(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsuxseg3ei32_v_f16mf2x3(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32_v_f16mf2x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16m1x3(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsuxseg3ei32_v_f16m1x3(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32_v_f16m1x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16m2x3(float16_t *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsuxseg3ei32_v_f16m2x3(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32_v_f16m2x3(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsuxseg3ei32_v_u64m2x3(uint64_t *rs1, vuint32m1_t vs2, vuint64m2x3_t v return __riscv_vsuxseg3ei32_v_u64m2x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsuxseg3ei32_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32_v_f16mf4x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsuxseg3ei32_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32_v_f16mf2x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsuxseg3ei32_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32_v_f16m1x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsuxseg3ei32_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32_v_f16m2x3_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg3ei64.c b/auto-generated/gnu-api-tests/vsuxseg3ei64.c index 77e83897c..7d0455c5b 100644 --- a/auto-generated/gnu-api-tests/vsuxseg3ei64.c +++ b/auto-generated/gnu-api-tests/vsuxseg3ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg3ei64_v_f16mf4x3(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsuxseg3ei64_v_f16mf4x3(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64_v_f16mf4x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16mf2x3(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsuxseg3ei64_v_f16mf2x3(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64_v_f16mf2x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16m1x3(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsuxseg3ei64_v_f16m1x3(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64_v_f16m1x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16m2x3(float16_t *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsuxseg3ei64_v_f16m2x3(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64_v_f16m2x3(rs1, vs2, vs3, vl); } @@ -147,19 +147,19 @@ void test_vsuxseg3ei64_v_u64m2x3(uint64_t *rs1, vuint64m2_t vs2, vuint64m2x3_t v return __riscv_vsuxseg3ei64_v_u64m2x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsuxseg3ei64_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64_v_f16mf4x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsuxseg3ei64_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64_v_f16mf2x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsuxseg3ei64_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64_v_f16m1x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsuxseg3ei64_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64_v_f16m2x3_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg3ei8.c b/auto-generated/gnu-api-tests/vsuxseg3ei8.c index ff228a009..69a3ef7c1 100644 --- a/auto-generated/gnu-api-tests/vsuxseg3ei8.c +++ b/auto-generated/gnu-api-tests/vsuxseg3ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg3ei8_v_f16mf4x3(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsuxseg3ei8_v_f16mf4x3(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8_v_f16mf4x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16mf2x3(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsuxseg3ei8_v_f16mf2x3(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8_v_f16mf2x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16m1x3(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsuxseg3ei8_v_f16m1x3(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8_v_f16m1x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16m2x3(float16_t *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsuxseg3ei8_v_f16m2x3(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8_v_f16m2x3(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsuxseg3ei8_v_u64m2x3(uint64_t *rs1, vuint8mf4_t vs2, vuint64m2x3_t vs return __riscv_vsuxseg3ei8_v_u64m2x3(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsuxseg3ei8_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8_v_f16mf4x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsuxseg3ei8_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8_v_f16mf2x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsuxseg3ei8_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8_v_f16m1x3_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsuxseg3ei8_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8_v_f16m2x3_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg4ei16.c b/auto-generated/gnu-api-tests/vsuxseg4ei16.c index 31541a5ee..8b7566444 100644 --- a/auto-generated/gnu-api-tests/vsuxseg4ei16.c +++ b/auto-generated/gnu-api-tests/vsuxseg4ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg4ei16_v_f16mf4x4(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsuxseg4ei16_v_f16mf4x4(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16_v_f16mf4x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16mf2x4(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsuxseg4ei16_v_f16mf2x4(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16_v_f16mf2x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16m1x4(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsuxseg4ei16_v_f16m1x4(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16_v_f16m1x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16m2x4(float16_t *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsuxseg4ei16_v_f16m2x4(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16_v_f16m2x4(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsuxseg4ei16_v_u64m2x4(uint64_t *rs1, vuint16mf2_t vs2, vuint64m2x4_t return __riscv_vsuxseg4ei16_v_u64m2x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsuxseg4ei16_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16_v_f16mf4x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsuxseg4ei16_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16_v_f16mf2x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsuxseg4ei16_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16_v_f16m1x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsuxseg4ei16_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16_v_f16m2x4_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg4ei32.c b/auto-generated/gnu-api-tests/vsuxseg4ei32.c index 10ef6b4ce..8df968f5f 100644 --- a/auto-generated/gnu-api-tests/vsuxseg4ei32.c +++ b/auto-generated/gnu-api-tests/vsuxseg4ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg4ei32_v_f16mf4x4(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsuxseg4ei32_v_f16mf4x4(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32_v_f16mf4x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16mf2x4(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsuxseg4ei32_v_f16mf2x4(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32_v_f16mf2x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16m1x4(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsuxseg4ei32_v_f16m1x4(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32_v_f16m1x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16m2x4(float16_t *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsuxseg4ei32_v_f16m2x4(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32_v_f16m2x4(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsuxseg4ei32_v_u64m2x4(uint64_t *rs1, vuint32m1_t vs2, vuint64m2x4_t v return __riscv_vsuxseg4ei32_v_u64m2x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsuxseg4ei32_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32_v_f16mf4x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsuxseg4ei32_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32_v_f16mf2x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsuxseg4ei32_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32_v_f16m1x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsuxseg4ei32_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32_v_f16m2x4_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg4ei64.c b/auto-generated/gnu-api-tests/vsuxseg4ei64.c index 56fae5cfd..d46dbcd85 100644 --- a/auto-generated/gnu-api-tests/vsuxseg4ei64.c +++ b/auto-generated/gnu-api-tests/vsuxseg4ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg4ei64_v_f16mf4x4(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsuxseg4ei64_v_f16mf4x4(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64_v_f16mf4x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16mf2x4(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsuxseg4ei64_v_f16mf2x4(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64_v_f16mf2x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16m1x4(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsuxseg4ei64_v_f16m1x4(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64_v_f16m1x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16m2x4(float16_t *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsuxseg4ei64_v_f16m2x4(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64_v_f16m2x4(rs1, vs2, vs3, vl); } @@ -147,19 +147,19 @@ void test_vsuxseg4ei64_v_u64m2x4(uint64_t *rs1, vuint64m2_t vs2, vuint64m2x4_t v return __riscv_vsuxseg4ei64_v_u64m2x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsuxseg4ei64_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64_v_f16mf4x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsuxseg4ei64_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64_v_f16mf2x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsuxseg4ei64_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64_v_f16m1x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsuxseg4ei64_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64_v_f16m2x4_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg4ei8.c b/auto-generated/gnu-api-tests/vsuxseg4ei8.c index 4705eb5fa..3ce45b4d6 100644 --- a/auto-generated/gnu-api-tests/vsuxseg4ei8.c +++ b/auto-generated/gnu-api-tests/vsuxseg4ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg4ei8_v_f16mf4x4(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsuxseg4ei8_v_f16mf4x4(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8_v_f16mf4x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16mf2x4(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsuxseg4ei8_v_f16mf2x4(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8_v_f16mf2x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16m1x4(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsuxseg4ei8_v_f16m1x4(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8_v_f16m1x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16m2x4(float16_t *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsuxseg4ei8_v_f16m2x4(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8_v_f16m2x4(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsuxseg4ei8_v_u64m2x4(uint64_t *rs1, vuint8mf4_t vs2, vuint64m2x4_t vs return __riscv_vsuxseg4ei8_v_u64m2x4(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsuxseg4ei8_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8_v_f16mf4x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsuxseg4ei8_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8_v_f16mf2x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsuxseg4ei8_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8_v_f16m1x4_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsuxseg4ei8_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8_v_f16m2x4_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg5ei16.c b/auto-generated/gnu-api-tests/vsuxseg5ei16.c index 6fd8a2a02..0e2bdee3d 100644 --- a/auto-generated/gnu-api-tests/vsuxseg5ei16.c +++ b/auto-generated/gnu-api-tests/vsuxseg5ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg5ei16_v_f16mf4x5(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsuxseg5ei16_v_f16mf4x5(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16_v_f16mf4x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16mf2x5(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsuxseg5ei16_v_f16mf2x5(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16_v_f16mf2x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16m1x5(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsuxseg5ei16_v_f16m1x5(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16_v_f16m1x5(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg5ei16_v_u64m1x5(uint64_t *rs1, vuint16mf4_t vs2, vuint64m1x5_t return __riscv_vsuxseg5ei16_v_u64m1x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsuxseg5ei16_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16_v_f16mf4x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsuxseg5ei16_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16_v_f16mf2x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsuxseg5ei16_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16_v_f16m1x5_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg5ei32.c b/auto-generated/gnu-api-tests/vsuxseg5ei32.c index 769e6a260..d4d1c5806 100644 --- a/auto-generated/gnu-api-tests/vsuxseg5ei32.c +++ b/auto-generated/gnu-api-tests/vsuxseg5ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg5ei32_v_f16mf4x5(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsuxseg5ei32_v_f16mf4x5(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32_v_f16mf4x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16mf2x5(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsuxseg5ei32_v_f16mf2x5(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32_v_f16mf2x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16m1x5(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsuxseg5ei32_v_f16m1x5(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32_v_f16m1x5(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg5ei32_v_u64m1x5(uint64_t *rs1, vuint32mf2_t vs2, vuint64m1x5_t return __riscv_vsuxseg5ei32_v_u64m1x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsuxseg5ei32_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32_v_f16mf4x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsuxseg5ei32_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32_v_f16mf2x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsuxseg5ei32_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32_v_f16m1x5_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg5ei64.c b/auto-generated/gnu-api-tests/vsuxseg5ei64.c index 8cb4b38a3..73383e339 100644 --- a/auto-generated/gnu-api-tests/vsuxseg5ei64.c +++ b/auto-generated/gnu-api-tests/vsuxseg5ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg5ei64_v_f16mf4x5(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsuxseg5ei64_v_f16mf4x5(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64_v_f16mf4x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16mf2x5(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsuxseg5ei64_v_f16mf2x5(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64_v_f16mf2x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16m1x5(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsuxseg5ei64_v_f16m1x5(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64_v_f16m1x5(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg5ei64_v_u64m1x5(uint64_t *rs1, vuint64m1_t vs2, vuint64m1x5_t v return __riscv_vsuxseg5ei64_v_u64m1x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsuxseg5ei64_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64_v_f16mf4x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsuxseg5ei64_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64_v_f16mf2x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsuxseg5ei64_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64_v_f16m1x5_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg5ei8.c b/auto-generated/gnu-api-tests/vsuxseg5ei8.c index 22bacce45..8d372a514 100644 --- a/auto-generated/gnu-api-tests/vsuxseg5ei8.c +++ b/auto-generated/gnu-api-tests/vsuxseg5ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg5ei8_v_f16mf4x5(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsuxseg5ei8_v_f16mf4x5(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8_v_f16mf4x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16mf2x5(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsuxseg5ei8_v_f16mf2x5(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8_v_f16mf2x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16m1x5(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsuxseg5ei8_v_f16m1x5(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8_v_f16m1x5(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg5ei8_v_u64m1x5(uint64_t *rs1, vuint8mf8_t vs2, vuint64m1x5_t vs return __riscv_vsuxseg5ei8_v_u64m1x5(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsuxseg5ei8_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8_v_f16mf4x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsuxseg5ei8_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8_v_f16mf2x5_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsuxseg5ei8_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8_v_f16m1x5_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg6ei16.c b/auto-generated/gnu-api-tests/vsuxseg6ei16.c index 43047a1be..f1419b4f0 100644 --- a/auto-generated/gnu-api-tests/vsuxseg6ei16.c +++ b/auto-generated/gnu-api-tests/vsuxseg6ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg6ei16_v_f16mf4x6(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsuxseg6ei16_v_f16mf4x6(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16_v_f16mf4x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16mf2x6(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsuxseg6ei16_v_f16mf2x6(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16_v_f16mf2x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16m1x6(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsuxseg6ei16_v_f16m1x6(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16_v_f16m1x6(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg6ei16_v_u64m1x6(uint64_t *rs1, vuint16mf4_t vs2, vuint64m1x6_t return __riscv_vsuxseg6ei16_v_u64m1x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsuxseg6ei16_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16_v_f16mf4x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsuxseg6ei16_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16_v_f16mf2x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsuxseg6ei16_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16_v_f16m1x6_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg6ei32.c b/auto-generated/gnu-api-tests/vsuxseg6ei32.c index ac9d590a8..0e3b2b259 100644 --- a/auto-generated/gnu-api-tests/vsuxseg6ei32.c +++ b/auto-generated/gnu-api-tests/vsuxseg6ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg6ei32_v_f16mf4x6(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsuxseg6ei32_v_f16mf4x6(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32_v_f16mf4x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16mf2x6(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsuxseg6ei32_v_f16mf2x6(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32_v_f16mf2x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16m1x6(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsuxseg6ei32_v_f16m1x6(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32_v_f16m1x6(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg6ei32_v_u64m1x6(uint64_t *rs1, vuint32mf2_t vs2, vuint64m1x6_t return __riscv_vsuxseg6ei32_v_u64m1x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsuxseg6ei32_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32_v_f16mf4x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsuxseg6ei32_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32_v_f16mf2x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsuxseg6ei32_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32_v_f16m1x6_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg6ei64.c b/auto-generated/gnu-api-tests/vsuxseg6ei64.c index 17cc3145f..3a8c994b0 100644 --- a/auto-generated/gnu-api-tests/vsuxseg6ei64.c +++ b/auto-generated/gnu-api-tests/vsuxseg6ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg6ei64_v_f16mf4x6(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsuxseg6ei64_v_f16mf4x6(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64_v_f16mf4x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16mf2x6(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsuxseg6ei64_v_f16mf2x6(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64_v_f16mf2x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16m1x6(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsuxseg6ei64_v_f16m1x6(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64_v_f16m1x6(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg6ei64_v_u64m1x6(uint64_t *rs1, vuint64m1_t vs2, vuint64m1x6_t v return __riscv_vsuxseg6ei64_v_u64m1x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsuxseg6ei64_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64_v_f16mf4x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsuxseg6ei64_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64_v_f16mf2x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsuxseg6ei64_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64_v_f16m1x6_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg6ei8.c b/auto-generated/gnu-api-tests/vsuxseg6ei8.c index 7e723d636..08a6cd286 100644 --- a/auto-generated/gnu-api-tests/vsuxseg6ei8.c +++ b/auto-generated/gnu-api-tests/vsuxseg6ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg6ei8_v_f16mf4x6(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsuxseg6ei8_v_f16mf4x6(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8_v_f16mf4x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16mf2x6(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsuxseg6ei8_v_f16mf2x6(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8_v_f16mf2x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16m1x6(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsuxseg6ei8_v_f16m1x6(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8_v_f16m1x6(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg6ei8_v_u64m1x6(uint64_t *rs1, vuint8mf8_t vs2, vuint64m1x6_t vs return __riscv_vsuxseg6ei8_v_u64m1x6(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsuxseg6ei8_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8_v_f16mf4x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsuxseg6ei8_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8_v_f16mf2x6_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsuxseg6ei8_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8_v_f16m1x6_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg7ei16.c b/auto-generated/gnu-api-tests/vsuxseg7ei16.c index f8569b7c5..ea87486b6 100644 --- a/auto-generated/gnu-api-tests/vsuxseg7ei16.c +++ b/auto-generated/gnu-api-tests/vsuxseg7ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg7ei16_v_f16mf4x7(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsuxseg7ei16_v_f16mf4x7(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16_v_f16mf4x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16mf2x7(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsuxseg7ei16_v_f16mf2x7(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16_v_f16mf2x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16m1x7(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsuxseg7ei16_v_f16m1x7(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16_v_f16m1x7(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg7ei16_v_u64m1x7(uint64_t *rs1, vuint16mf4_t vs2, vuint64m1x7_t return __riscv_vsuxseg7ei16_v_u64m1x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsuxseg7ei16_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16_v_f16mf4x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsuxseg7ei16_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16_v_f16mf2x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsuxseg7ei16_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16_v_f16m1x7_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg7ei32.c b/auto-generated/gnu-api-tests/vsuxseg7ei32.c index f81be2673..10c7a3bc3 100644 --- a/auto-generated/gnu-api-tests/vsuxseg7ei32.c +++ b/auto-generated/gnu-api-tests/vsuxseg7ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg7ei32_v_f16mf4x7(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsuxseg7ei32_v_f16mf4x7(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32_v_f16mf4x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16mf2x7(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsuxseg7ei32_v_f16mf2x7(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32_v_f16mf2x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16m1x7(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsuxseg7ei32_v_f16m1x7(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32_v_f16m1x7(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg7ei32_v_u64m1x7(uint64_t *rs1, vuint32mf2_t vs2, vuint64m1x7_t return __riscv_vsuxseg7ei32_v_u64m1x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsuxseg7ei32_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32_v_f16mf4x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsuxseg7ei32_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32_v_f16mf2x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsuxseg7ei32_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32_v_f16m1x7_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg7ei64.c b/auto-generated/gnu-api-tests/vsuxseg7ei64.c index c13ad6529..75508b17a 100644 --- a/auto-generated/gnu-api-tests/vsuxseg7ei64.c +++ b/auto-generated/gnu-api-tests/vsuxseg7ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg7ei64_v_f16mf4x7(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsuxseg7ei64_v_f16mf4x7(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64_v_f16mf4x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16mf2x7(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsuxseg7ei64_v_f16mf2x7(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64_v_f16mf2x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16m1x7(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsuxseg7ei64_v_f16m1x7(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64_v_f16m1x7(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg7ei64_v_u64m1x7(uint64_t *rs1, vuint64m1_t vs2, vuint64m1x7_t v return __riscv_vsuxseg7ei64_v_u64m1x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsuxseg7ei64_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64_v_f16mf4x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsuxseg7ei64_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64_v_f16mf2x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsuxseg7ei64_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64_v_f16m1x7_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg7ei8.c b/auto-generated/gnu-api-tests/vsuxseg7ei8.c index 2520c05b4..795bc8e1c 100644 --- a/auto-generated/gnu-api-tests/vsuxseg7ei8.c +++ b/auto-generated/gnu-api-tests/vsuxseg7ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg7ei8_v_f16mf4x7(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsuxseg7ei8_v_f16mf4x7(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8_v_f16mf4x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16mf2x7(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsuxseg7ei8_v_f16mf2x7(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8_v_f16mf2x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16m1x7(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsuxseg7ei8_v_f16m1x7(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8_v_f16m1x7(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg7ei8_v_u64m1x7(uint64_t *rs1, vuint8mf8_t vs2, vuint64m1x7_t vs return __riscv_vsuxseg7ei8_v_u64m1x7(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsuxseg7ei8_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8_v_f16mf4x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsuxseg7ei8_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8_v_f16mf2x7_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsuxseg7ei8_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8_v_f16m1x7_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg8ei16.c b/auto-generated/gnu-api-tests/vsuxseg8ei16.c index 76a5016a3..9b1a73302 100644 --- a/auto-generated/gnu-api-tests/vsuxseg8ei16.c +++ b/auto-generated/gnu-api-tests/vsuxseg8ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg8ei16_v_f16mf4x8(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsuxseg8ei16_v_f16mf4x8(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16_v_f16mf4x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16mf2x8(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsuxseg8ei16_v_f16mf2x8(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16_v_f16mf2x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16m1x8(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsuxseg8ei16_v_f16m1x8(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16_v_f16m1x8(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg8ei16_v_u64m1x8(uint64_t *rs1, vuint16mf4_t vs2, vuint64m1x8_t return __riscv_vsuxseg8ei16_v_u64m1x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsuxseg8ei16_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16_v_f16mf4x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsuxseg8ei16_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16_v_f16mf2x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsuxseg8ei16_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16_v_f16m1x8_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg8ei32.c b/auto-generated/gnu-api-tests/vsuxseg8ei32.c index c6892853f..aeca6629e 100644 --- a/auto-generated/gnu-api-tests/vsuxseg8ei32.c +++ b/auto-generated/gnu-api-tests/vsuxseg8ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg8ei32_v_f16mf4x8(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsuxseg8ei32_v_f16mf4x8(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32_v_f16mf4x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16mf2x8(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsuxseg8ei32_v_f16mf2x8(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32_v_f16mf2x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16m1x8(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsuxseg8ei32_v_f16m1x8(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32_v_f16m1x8(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg8ei32_v_u64m1x8(uint64_t *rs1, vuint32mf2_t vs2, vuint64m1x8_t return __riscv_vsuxseg8ei32_v_u64m1x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsuxseg8ei32_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32_v_f16mf4x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsuxseg8ei32_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32_v_f16mf2x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsuxseg8ei32_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32_v_f16m1x8_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg8ei64.c b/auto-generated/gnu-api-tests/vsuxseg8ei64.c index ce4ce6213..ba7d6049f 100644 --- a/auto-generated/gnu-api-tests/vsuxseg8ei64.c +++ b/auto-generated/gnu-api-tests/vsuxseg8ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg8ei64_v_f16mf4x8(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsuxseg8ei64_v_f16mf4x8(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64_v_f16mf4x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16mf2x8(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsuxseg8ei64_v_f16mf2x8(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64_v_f16mf2x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16m1x8(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsuxseg8ei64_v_f16m1x8(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64_v_f16m1x8(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg8ei64_v_u64m1x8(uint64_t *rs1, vuint64m1_t vs2, vuint64m1x8_t v return __riscv_vsuxseg8ei64_v_u64m1x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsuxseg8ei64_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64_v_f16mf4x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsuxseg8ei64_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64_v_f16mf2x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsuxseg8ei64_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64_v_f16m1x8_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-api-tests/vsuxseg8ei8.c b/auto-generated/gnu-api-tests/vsuxseg8ei8.c index 89bfb8e89..2d39c139e 100644 --- a/auto-generated/gnu-api-tests/vsuxseg8ei8.c +++ b/auto-generated/gnu-api-tests/vsuxseg8ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg8ei8_v_f16mf4x8(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsuxseg8ei8_v_f16mf4x8(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8_v_f16mf4x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16mf2x8(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsuxseg8ei8_v_f16mf2x8(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8_v_f16mf2x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16m1x8(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsuxseg8ei8_v_f16m1x8(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8_v_f16m1x8(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg8ei8_v_u64m1x8(uint64_t *rs1, vuint8mf8_t vs2, vuint64m1x8_t vs return __riscv_vsuxseg8ei8_v_u64m1x8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsuxseg8ei8_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8_v_f16mf4x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsuxseg8ei8_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8_v_f16mf2x8_m(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsuxseg8ei8_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8_v_f16m1x8_m(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vle16.c b/auto-generated/gnu-overloaded-tests/vle16.c index 3e8255dbe..eb744f6ec 100644 --- a/auto-generated/gnu-overloaded-tests/vle16.c +++ b/auto-generated/gnu-overloaded-tests/vle16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vle16_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf4_t test_vle16_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16(vm, rs1, vl); } -vfloat16mf2_t test_vle16_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf2_t test_vle16_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16(vm, rs1, vl); } -vfloat16m1_t test_vle16_v_f16m1_m(vbool16_t vm, const float16_t *rs1, size_t vl) { +vfloat16m1_t test_vle16_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16(vm, rs1, vl); } -vfloat16m2_t test_vle16_v_f16m2_m(vbool8_t vm, const float16_t *rs1, size_t vl) { +vfloat16m2_t test_vle16_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16(vm, rs1, vl); } -vfloat16m4_t test_vle16_v_f16m4_m(vbool4_t vm, const float16_t *rs1, size_t vl) { +vfloat16m4_t test_vle16_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16(vm, rs1, vl); } -vfloat16m8_t test_vle16_v_f16m8_m(vbool2_t vm, const float16_t *rs1, size_t vl) { +vfloat16m8_t test_vle16_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16(vm, rs1, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vle16ff.c b/auto-generated/gnu-overloaded-tests/vle16ff.c index 20058bf27..b4c392294 100644 --- a/auto-generated/gnu-overloaded-tests/vle16ff.c +++ b/auto-generated/gnu-overloaded-tests/vle16ff.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vle16ff_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4_t test_vle16ff_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff(vm, rs1, new_vl, vl); } -vfloat16mf2_t test_vle16ff_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2_t test_vle16ff_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff(vm, rs1, new_vl, vl); } -vfloat16m1_t test_vle16ff_v_f16m1_m(vbool16_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1_t test_vle16ff_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff(vm, rs1, new_vl, vl); } -vfloat16m2_t test_vle16ff_v_f16m2_m(vbool8_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2_t test_vle16ff_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff(vm, rs1, new_vl, vl); } -vfloat16m4_t test_vle16ff_v_f16m4_m(vbool4_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4_t test_vle16ff_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff(vm, rs1, new_vl, vl); } -vfloat16m8_t test_vle16ff_v_f16m8_m(vbool2_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m8_t test_vle16ff_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff(vm, rs1, new_vl, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxei16.c b/auto-generated/gnu-overloaded-tests/vloxei16.c index afa60d0d0..c41c8a143 100644 --- a/auto-generated/gnu-overloaded-tests/vloxei16.c +++ b/auto-generated/gnu-overloaded-tests/vloxei16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei16_v_f16mf4(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei16_v_f16mf4(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16(rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei16_v_f16mf2(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16(rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vloxei16_v_f16m1(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16(rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2(const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vloxei16_v_f16m2(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16(rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4(const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vloxei16_v_f16m4(const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16(rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8(const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vloxei16_v_f16m8(const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16(rs1, rs2, vl); } @@ -235,27 +235,27 @@ vuint64m8_t test_vloxei16_v_u64m8(const uint64_t *rs1, vuint16m2_t rs2, size_t v return __riscv_vloxei16(rs1, rs2, vl); } -vfloat16mf4_t test_vloxei16_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei16_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei16_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16(vm, rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vloxei16_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16(vm, rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2_m(vbool8_t vm, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vloxei16_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16(vm, rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4_m(vbool4_t vm, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vloxei16_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16(vm, rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8_m(vbool2_t vm, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vloxei16_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxei32.c b/auto-generated/gnu-overloaded-tests/vloxei32.c index 7eb195797..73b32e9d0 100644 --- a/auto-generated/gnu-overloaded-tests/vloxei32.c +++ b/auto-generated/gnu-overloaded-tests/vloxei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei32_v_f16mf4(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei32_v_f16mf4(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32(rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei32_v_f16mf2(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32(rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei32_v_f16m1(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32(rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2(const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vloxei32_v_f16m2(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32(rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4(const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vloxei32_v_f16m4(const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32(rs1, rs2, vl); } @@ -215,23 +215,23 @@ vuint64m8_t test_vloxei32_v_u64m8(const uint64_t *rs1, vuint32m4_t rs2, size_t v return __riscv_vloxei32(rs1, rs2, vl); } -vfloat16mf4_t test_vloxei32_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei32_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei32_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32(vm, rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei32_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32(vm, rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2_m(vbool8_t vm, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vloxei32_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32(vm, rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4_m(vbool4_t vm, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vloxei32_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxei64.c b/auto-generated/gnu-overloaded-tests/vloxei64.c index fa7252383..940030c79 100644 --- a/auto-generated/gnu-overloaded-tests/vloxei64.c +++ b/auto-generated/gnu-overloaded-tests/vloxei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei64_v_f16mf4(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei64_v_f16mf4(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64(rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei64_v_f16mf2(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64(rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vloxei64_v_f16m1(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64(rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2(const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vloxei64_v_f16m2(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64(rs1, rs2, vl); } @@ -183,19 +183,19 @@ vuint64m8_t test_vloxei64_v_u64m8(const uint64_t *rs1, vuint64m8_t rs2, size_t v return __riscv_vloxei64(rs1, rs2, vl); } -vfloat16mf4_t test_vloxei64_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei64_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei64_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64(vm, rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vloxei64_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64(vm, rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2_m(vbool8_t vm, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vloxei64_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxei8.c b/auto-generated/gnu-overloaded-tests/vloxei8.c index 53e2b7a21..078789926 100644 --- a/auto-generated/gnu-overloaded-tests/vloxei8.c +++ b/auto-generated/gnu-overloaded-tests/vloxei8.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei8_v_f16mf4(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei8_v_f16mf4(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8(rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei8_v_f16mf2(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8(rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei8_v_f16m1(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8(rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2(const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vloxei8_v_f16m2(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8(rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4(const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vloxei8_v_f16m4(const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8(rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8(const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vloxei8_v_f16m8(const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8(rs1, rs2, vl); } @@ -243,27 +243,27 @@ vuint64m8_t test_vloxei8_v_u64m8(const uint64_t *rs1, vuint8m1_t rs2, size_t vl) return __riscv_vloxei8(rs1, rs2, vl); } -vfloat16mf4_t test_vloxei8_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei8_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei8_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8(vm, rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei8_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8(vm, rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2_m(vbool8_t vm, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vloxei8_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8(vm, rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4_m(vbool4_t vm, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vloxei8_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8(vm, rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8_m(vbool2_t vm, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vloxei8_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg2ei16.c b/auto-generated/gnu-overloaded-tests/vloxseg2ei16.c index 6e4cf52ee..ea33e86ec 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg2ei16.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg2ei16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16(rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16(rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16(rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2(const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16(rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2(const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2(const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16(rs1, rs2, vl); } @@ -199,23 +199,23 @@ vuint64m4x2_t test_vloxseg2ei16_v_u64m4x2(const uint64_t *rs1, vuint16m1_t rs2, return __riscv_vloxseg2ei16(rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg2ei32.c b/auto-generated/gnu-overloaded-tests/vloxseg2ei32.c index 196c44733..9d53c6dbe 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg2ei32.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg2ei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32(rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32(rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32(rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2(const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32(rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2(const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2(const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m4x2_t test_vloxseg2ei32_v_u64m4x2(const uint64_t *rs1, vuint32m2_t rs2, return __riscv_vloxseg2ei32(rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg2ei64.c b/auto-generated/gnu-overloaded-tests/vloxseg2ei64.c index 5157f5ab4..6ea5e58cb 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg2ei64.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg2ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64(rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64(rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64(rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2(const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64(rs1, rs2, vl); } @@ -171,19 +171,19 @@ vuint64m4x2_t test_vloxseg2ei64_v_u64m4x2(const uint64_t *rs1, vuint64m4_t rs2, return __riscv_vloxseg2ei64(rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg2ei8.c b/auto-generated/gnu-overloaded-tests/vloxseg2ei8.c index abbf126ba..f7ae00396 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg2ei8.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg2ei8.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8(rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8(rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8(rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2(const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8(rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2(const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2(const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8(rs1, rs2, vl); } @@ -199,23 +199,23 @@ vuint64m4x2_t test_vloxseg2ei8_v_u64m4x2(const uint64_t *rs1, vuint8mf2_t rs2, s return __riscv_vloxseg2ei8(rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg3ei16.c b/auto-generated/gnu-overloaded-tests/vloxseg3ei16.c index f8b430cbb..bd9c5e013 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg3ei16.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg3ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16(rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16(rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16(rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3(const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vloxseg3ei16_v_u64m2x3(const uint64_t *rs1, vuint16mf2_t rs2, return __riscv_vloxseg3ei16(rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg3ei32.c b/auto-generated/gnu-overloaded-tests/vloxseg3ei32.c index 526037a68..ec59d626c 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg3ei32.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg3ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32(rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32(rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32(rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3(const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vloxseg3ei32_v_u64m2x3(const uint64_t *rs1, vuint32m1_t rs2, return __riscv_vloxseg3ei32(rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg3ei64.c b/auto-generated/gnu-overloaded-tests/vloxseg3ei64.c index 2d8084412..1620fc7c7 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg3ei64.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg3ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64(rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64(rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64(rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3(const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64(rs1, rs2, vl); } @@ -147,19 +147,19 @@ vuint64m2x3_t test_vloxseg3ei64_v_u64m2x3(const uint64_t *rs1, vuint64m2_t rs2, return __riscv_vloxseg3ei64(rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg3ei8.c b/auto-generated/gnu-overloaded-tests/vloxseg3ei8.c index 9327d4d56..05855049d 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg3ei8.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg3ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8(rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8(rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8(rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3(const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vloxseg3ei8_v_u64m2x3(const uint64_t *rs1, vuint8mf4_t rs2, s return __riscv_vloxseg3ei8(rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg4ei16.c b/auto-generated/gnu-overloaded-tests/vloxseg4ei16.c index 67ce5bb6d..208347591 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg4ei16.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg4ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16(rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16(rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16(rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4(const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vloxseg4ei16_v_u64m2x4(const uint64_t *rs1, vuint16mf2_t rs2, return __riscv_vloxseg4ei16(rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg4ei32.c b/auto-generated/gnu-overloaded-tests/vloxseg4ei32.c index 289ff4b03..40f2c5e70 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg4ei32.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg4ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32(rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32(rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32(rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4(const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vloxseg4ei32_v_u64m2x4(const uint64_t *rs1, vuint32m1_t rs2, return __riscv_vloxseg4ei32(rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg4ei64.c b/auto-generated/gnu-overloaded-tests/vloxseg4ei64.c index 8028e8d8c..b7a822993 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg4ei64.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg4ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64(rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64(rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64(rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4(const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64(rs1, rs2, vl); } @@ -147,19 +147,19 @@ vuint64m2x4_t test_vloxseg4ei64_v_u64m2x4(const uint64_t *rs1, vuint64m2_t rs2, return __riscv_vloxseg4ei64(rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg4ei8.c b/auto-generated/gnu-overloaded-tests/vloxseg4ei8.c index 45fb67a9c..828cce3c6 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg4ei8.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg4ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8(rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8(rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8(rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4(const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vloxseg4ei8_v_u64m2x4(const uint64_t *rs1, vuint8mf4_t rs2, s return __riscv_vloxseg4ei8(rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg5ei16.c b/auto-generated/gnu-overloaded-tests/vloxseg5ei16.c index 132e2b038..7ac560bf1 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg5ei16.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg5ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16(rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16(rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vloxseg5ei16_v_u64m1x5(const uint64_t *rs1, vuint16mf4_t rs2, return __riscv_vloxseg5ei16(rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg5ei32.c b/auto-generated/gnu-overloaded-tests/vloxseg5ei32.c index 3319f2cf2..91635298b 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg5ei32.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg5ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32(rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32(rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vloxseg5ei32_v_u64m1x5(const uint64_t *rs1, vuint32mf2_t rs2, return __riscv_vloxseg5ei32(rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg5ei64.c b/auto-generated/gnu-overloaded-tests/vloxseg5ei64.c index 123e7a0e8..a004bf0fe 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg5ei64.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg5ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64(rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64(rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vloxseg5ei64_v_u64m1x5(const uint64_t *rs1, vuint64m1_t rs2, return __riscv_vloxseg5ei64(rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg5ei8.c b/auto-generated/gnu-overloaded-tests/vloxseg5ei8.c index 056a27440..1e257dd3a 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg5ei8.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg5ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8(rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8(rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vloxseg5ei8_v_u64m1x5(const uint64_t *rs1, vuint8mf8_t rs2, s return __riscv_vloxseg5ei8(rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg6ei16.c b/auto-generated/gnu-overloaded-tests/vloxseg6ei16.c index bee1d9b6d..8e04ac478 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg6ei16.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg6ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16(rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16(rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vloxseg6ei16_v_u64m1x6(const uint64_t *rs1, vuint16mf4_t rs2, return __riscv_vloxseg6ei16(rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg6ei32.c b/auto-generated/gnu-overloaded-tests/vloxseg6ei32.c index efdc00361..6bbd2fd8b 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg6ei32.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg6ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32(rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32(rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vloxseg6ei32_v_u64m1x6(const uint64_t *rs1, vuint32mf2_t rs2, return __riscv_vloxseg6ei32(rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg6ei64.c b/auto-generated/gnu-overloaded-tests/vloxseg6ei64.c index cf32ccb17..e360b37b5 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg6ei64.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg6ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64(rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64(rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vloxseg6ei64_v_u64m1x6(const uint64_t *rs1, vuint64m1_t rs2, return __riscv_vloxseg6ei64(rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg6ei8.c b/auto-generated/gnu-overloaded-tests/vloxseg6ei8.c index 6ce047157..db850b887 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg6ei8.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg6ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8(rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8(rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vloxseg6ei8_v_u64m1x6(const uint64_t *rs1, vuint8mf8_t rs2, s return __riscv_vloxseg6ei8(rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg7ei16.c b/auto-generated/gnu-overloaded-tests/vloxseg7ei16.c index b98cf3c4d..cd4baa71d 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg7ei16.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg7ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16(rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16(rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vloxseg7ei16_v_u64m1x7(const uint64_t *rs1, vuint16mf4_t rs2, return __riscv_vloxseg7ei16(rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg7ei32.c b/auto-generated/gnu-overloaded-tests/vloxseg7ei32.c index ebb49aedc..4f13949b3 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg7ei32.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg7ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32(rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32(rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vloxseg7ei32_v_u64m1x7(const uint64_t *rs1, vuint32mf2_t rs2, return __riscv_vloxseg7ei32(rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg7ei64.c b/auto-generated/gnu-overloaded-tests/vloxseg7ei64.c index a285ae8be..98e6859e7 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg7ei64.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg7ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64(rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64(rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vloxseg7ei64_v_u64m1x7(const uint64_t *rs1, vuint64m1_t rs2, return __riscv_vloxseg7ei64(rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg7ei8.c b/auto-generated/gnu-overloaded-tests/vloxseg7ei8.c index d10f847fa..3f87c677e 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg7ei8.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg7ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8(rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8(rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vloxseg7ei8_v_u64m1x7(const uint64_t *rs1, vuint8mf8_t rs2, s return __riscv_vloxseg7ei8(rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg8ei16.c b/auto-generated/gnu-overloaded-tests/vloxseg8ei16.c index a35469809..3557571f1 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg8ei16.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg8ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16(rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16(rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vloxseg8ei16_v_u64m1x8(const uint64_t *rs1, vuint16mf4_t rs2, return __riscv_vloxseg8ei16(rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg8ei32.c b/auto-generated/gnu-overloaded-tests/vloxseg8ei32.c index 9b5b63a53..822bd674b 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg8ei32.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg8ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32(rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32(rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vloxseg8ei32_v_u64m1x8(const uint64_t *rs1, vuint32mf2_t rs2, return __riscv_vloxseg8ei32(rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg8ei64.c b/auto-generated/gnu-overloaded-tests/vloxseg8ei64.c index 34e7b28f0..555f65296 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg8ei64.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg8ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64(rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64(rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vloxseg8ei64_v_u64m1x8(const uint64_t *rs1, vuint64m1_t rs2, return __riscv_vloxseg8ei64(rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vloxseg8ei8.c b/auto-generated/gnu-overloaded-tests/vloxseg8ei8.c index 18c370a82..840f6ac69 100644 --- a/auto-generated/gnu-overloaded-tests/vloxseg8ei8.c +++ b/auto-generated/gnu-overloaded-tests/vloxseg8ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8(rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vloxseg8ei8_v_u64m1x8(const uint64_t *rs1, vuint8mf8_t rs2, s return __riscv_vloxseg8ei8(rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlse16.c b/auto-generated/gnu-overloaded-tests/vlse16.c index 34b75c777..65e287d5f 100644 --- a/auto-generated/gnu-overloaded-tests/vlse16.c +++ b/auto-generated/gnu-overloaded-tests/vlse16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vlse16_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4_t test_vlse16_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vlse16_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2_t test_vlse16_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16(vm, rs1, rs2, vl); } -vfloat16m1_t test_vlse16_v_f16m1_m(vbool16_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1_t test_vlse16_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16(vm, rs1, rs2, vl); } -vfloat16m2_t test_vlse16_v_f16m2_m(vbool8_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2_t test_vlse16_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16(vm, rs1, rs2, vl); } -vfloat16m4_t test_vlse16_v_f16m4_m(vbool4_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4_t test_vlse16_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16(vm, rs1, rs2, vl); } -vfloat16m8_t test_vlse16_v_f16m8_m(vbool2_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m8_t test_vlse16_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlseg2e16.c b/auto-generated/gnu-overloaded-tests/vlseg2e16.c index 5da0fead7..90a50f655 100644 --- a/auto-generated/gnu-overloaded-tests/vlseg2e16.c +++ b/auto-generated/gnu-overloaded-tests/vlseg2e16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16(vm, rs1, vl); } -vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16(vm, rs1, vl); } -vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, size_t vl) { +vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16(vm, rs1, vl); } -vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, size_t vl) { +vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16(vm, rs1, vl); } -vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, size_t vl) { +vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16(vm, rs1, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlseg2e16ff.c b/auto-generated/gnu-overloaded-tests/vlseg2e16ff.c index 46399bf02..07d12d057 100644 --- a/auto-generated/gnu-overloaded-tests/vlseg2e16ff.c +++ b/auto-generated/gnu-overloaded-tests/vlseg2e16ff.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff(vm, rs1, new_vl, vl); } -vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff(vm, rs1, new_vl, vl); } -vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff(vm, rs1, new_vl, vl); } -vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff(vm, rs1, new_vl, vl); } -vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff(vm, rs1, new_vl, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlseg3e16.c b/auto-generated/gnu-overloaded-tests/vlseg3e16.c index 26a325f09..daf21b31a 100644 --- a/auto-generated/gnu-overloaded-tests/vlseg3e16.c +++ b/auto-generated/gnu-overloaded-tests/vlseg3e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16(vm, rs1, vl); } -vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16(vm, rs1, vl); } -vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, size_t vl) { +vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16(vm, rs1, vl); } -vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, size_t vl) { +vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16(vm, rs1, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlseg3e16ff.c b/auto-generated/gnu-overloaded-tests/vlseg3e16ff.c index 66defbffc..3e8ec08f2 100644 --- a/auto-generated/gnu-overloaded-tests/vlseg3e16ff.c +++ b/auto-generated/gnu-overloaded-tests/vlseg3e16ff.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff(vm, rs1, new_vl, vl); } -vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff(vm, rs1, new_vl, vl); } -vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff(vm, rs1, new_vl, vl); } -vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff(vm, rs1, new_vl, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlseg4e16.c b/auto-generated/gnu-overloaded-tests/vlseg4e16.c index 128058ffa..6edbcc3da 100644 --- a/auto-generated/gnu-overloaded-tests/vlseg4e16.c +++ b/auto-generated/gnu-overloaded-tests/vlseg4e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16(vm, rs1, vl); } -vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16(vm, rs1, vl); } -vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, size_t vl) { +vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16(vm, rs1, vl); } -vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, size_t vl) { +vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16(vm, rs1, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlseg4e16ff.c b/auto-generated/gnu-overloaded-tests/vlseg4e16ff.c index 29892a67e..b2c1f9265 100644 --- a/auto-generated/gnu-overloaded-tests/vlseg4e16ff.c +++ b/auto-generated/gnu-overloaded-tests/vlseg4e16ff.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff(vm, rs1, new_vl, vl); } -vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff(vm, rs1, new_vl, vl); } -vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff(vm, rs1, new_vl, vl); } -vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff(vm, rs1, new_vl, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlseg5e16.c b/auto-generated/gnu-overloaded-tests/vlseg5e16.c index 6cd9a01c8..422575738 100644 --- a/auto-generated/gnu-overloaded-tests/vlseg5e16.c +++ b/auto-generated/gnu-overloaded-tests/vlseg5e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16(vm, rs1, vl); } -vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16(vm, rs1, vl); } -vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, size_t vl) { +vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16(vm, rs1, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlseg5e16ff.c b/auto-generated/gnu-overloaded-tests/vlseg5e16ff.c index 6cc1268fc..4269ba421 100644 --- a/auto-generated/gnu-overloaded-tests/vlseg5e16ff.c +++ b/auto-generated/gnu-overloaded-tests/vlseg5e16ff.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff(vm, rs1, new_vl, vl); } -vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff(vm, rs1, new_vl, vl); } -vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff(vm, rs1, new_vl, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlseg6e16.c b/auto-generated/gnu-overloaded-tests/vlseg6e16.c index 162a63694..734dda718 100644 --- a/auto-generated/gnu-overloaded-tests/vlseg6e16.c +++ b/auto-generated/gnu-overloaded-tests/vlseg6e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16(vm, rs1, vl); } -vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16(vm, rs1, vl); } -vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, size_t vl) { +vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16(vm, rs1, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlseg6e16ff.c b/auto-generated/gnu-overloaded-tests/vlseg6e16ff.c index e9a07e9a9..91ab28c4b 100644 --- a/auto-generated/gnu-overloaded-tests/vlseg6e16ff.c +++ b/auto-generated/gnu-overloaded-tests/vlseg6e16ff.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff(vm, rs1, new_vl, vl); } -vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff(vm, rs1, new_vl, vl); } -vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff(vm, rs1, new_vl, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlseg7e16.c b/auto-generated/gnu-overloaded-tests/vlseg7e16.c index 4a61a98ac..4d1f19256 100644 --- a/auto-generated/gnu-overloaded-tests/vlseg7e16.c +++ b/auto-generated/gnu-overloaded-tests/vlseg7e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16(vm, rs1, vl); } -vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16(vm, rs1, vl); } -vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, size_t vl) { +vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16(vm, rs1, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlseg7e16ff.c b/auto-generated/gnu-overloaded-tests/vlseg7e16ff.c index 141958fc9..a9bf730f8 100644 --- a/auto-generated/gnu-overloaded-tests/vlseg7e16ff.c +++ b/auto-generated/gnu-overloaded-tests/vlseg7e16ff.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff(vm, rs1, new_vl, vl); } -vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff(vm, rs1, new_vl, vl); } -vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff(vm, rs1, new_vl, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlseg8e16.c b/auto-generated/gnu-overloaded-tests/vlseg8e16.c index 52593d0d3..bcd0ddf98 100644 --- a/auto-generated/gnu-overloaded-tests/vlseg8e16.c +++ b/auto-generated/gnu-overloaded-tests/vlseg8e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16(vm, rs1, vl); } -vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16(vm, rs1, vl); } -vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, size_t vl) { +vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16(vm, rs1, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlseg8e16ff.c b/auto-generated/gnu-overloaded-tests/vlseg8e16ff.c index 9c96ded74..402a9f99e 100644 --- a/auto-generated/gnu-overloaded-tests/vlseg8e16ff.c +++ b/auto-generated/gnu-overloaded-tests/vlseg8e16ff.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff(vm, rs1, new_vl, vl); } -vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff(vm, rs1, new_vl, vl); } -vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff(vm, rs1, new_vl, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlsseg2e16.c b/auto-generated/gnu-overloaded-tests/vlsseg2e16.c index 0a122ead4..35b86b854 100644 --- a/auto-generated/gnu-overloaded-tests/vlsseg2e16.c +++ b/auto-generated/gnu-overloaded-tests/vlsseg2e16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlsseg3e16.c b/auto-generated/gnu-overloaded-tests/vlsseg3e16.c index 9118b87dc..f51cf30c2 100644 --- a/auto-generated/gnu-overloaded-tests/vlsseg3e16.c +++ b/auto-generated/gnu-overloaded-tests/vlsseg3e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlsseg4e16.c b/auto-generated/gnu-overloaded-tests/vlsseg4e16.c index f8ff8b3e9..f99d23629 100644 --- a/auto-generated/gnu-overloaded-tests/vlsseg4e16.c +++ b/auto-generated/gnu-overloaded-tests/vlsseg4e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlsseg5e16.c b/auto-generated/gnu-overloaded-tests/vlsseg5e16.c index 7a0eaf26c..9e5f3e4ed 100644 --- a/auto-generated/gnu-overloaded-tests/vlsseg5e16.c +++ b/auto-generated/gnu-overloaded-tests/vlsseg5e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlsseg6e16.c b/auto-generated/gnu-overloaded-tests/vlsseg6e16.c index afe78f517..cb47d44b7 100644 --- a/auto-generated/gnu-overloaded-tests/vlsseg6e16.c +++ b/auto-generated/gnu-overloaded-tests/vlsseg6e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlsseg7e16.c b/auto-generated/gnu-overloaded-tests/vlsseg7e16.c index 2e7a4362c..dd160d2dd 100644 --- a/auto-generated/gnu-overloaded-tests/vlsseg7e16.c +++ b/auto-generated/gnu-overloaded-tests/vlsseg7e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vlsseg8e16.c b/auto-generated/gnu-overloaded-tests/vlsseg8e16.c index 350af6c9e..c0d4621d0 100644 --- a/auto-generated/gnu-overloaded-tests/vlsseg8e16.c +++ b/auto-generated/gnu-overloaded-tests/vlsseg8e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxei16.c b/auto-generated/gnu-overloaded-tests/vluxei16.c index 8d3ed5cf5..90728ecbe 100644 --- a/auto-generated/gnu-overloaded-tests/vluxei16.c +++ b/auto-generated/gnu-overloaded-tests/vluxei16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei16_v_f16mf4(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei16_v_f16mf4(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16(rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei16_v_f16mf2(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16(rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vluxei16_v_f16m1(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16(rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2(const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vluxei16_v_f16m2(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16(rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4(const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vluxei16_v_f16m4(const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16(rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8(const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vluxei16_v_f16m8(const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16(rs1, rs2, vl); } @@ -235,27 +235,27 @@ vuint64m8_t test_vluxei16_v_u64m8(const uint64_t *rs1, vuint16m2_t rs2, size_t v return __riscv_vluxei16(rs1, rs2, vl); } -vfloat16mf4_t test_vluxei16_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei16_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei16_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16(vm, rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vluxei16_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16(vm, rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2_m(vbool8_t vm, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vluxei16_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16(vm, rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4_m(vbool4_t vm, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vluxei16_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16(vm, rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8_m(vbool2_t vm, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vluxei16_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxei32.c b/auto-generated/gnu-overloaded-tests/vluxei32.c index db0f4da73..0ef2d0ec5 100644 --- a/auto-generated/gnu-overloaded-tests/vluxei32.c +++ b/auto-generated/gnu-overloaded-tests/vluxei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei32_v_f16mf4(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei32_v_f16mf4(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32(rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei32_v_f16mf2(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32(rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei32_v_f16m1(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32(rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2(const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vluxei32_v_f16m2(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32(rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4(const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vluxei32_v_f16m4(const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32(rs1, rs2, vl); } @@ -215,23 +215,23 @@ vuint64m8_t test_vluxei32_v_u64m8(const uint64_t *rs1, vuint32m4_t rs2, size_t v return __riscv_vluxei32(rs1, rs2, vl); } -vfloat16mf4_t test_vluxei32_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei32_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei32_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32(vm, rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei32_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32(vm, rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2_m(vbool8_t vm, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vluxei32_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32(vm, rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4_m(vbool4_t vm, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vluxei32_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxei64.c b/auto-generated/gnu-overloaded-tests/vluxei64.c index 33e575d90..4a774d20a 100644 --- a/auto-generated/gnu-overloaded-tests/vluxei64.c +++ b/auto-generated/gnu-overloaded-tests/vluxei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei64_v_f16mf4(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei64_v_f16mf4(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64(rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei64_v_f16mf2(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64(rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vluxei64_v_f16m1(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64(rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2(const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vluxei64_v_f16m2(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64(rs1, rs2, vl); } @@ -183,19 +183,19 @@ vuint64m8_t test_vluxei64_v_u64m8(const uint64_t *rs1, vuint64m8_t rs2, size_t v return __riscv_vluxei64(rs1, rs2, vl); } -vfloat16mf4_t test_vluxei64_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei64_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei64_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64(vm, rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vluxei64_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64(vm, rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2_m(vbool8_t vm, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vluxei64_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxei8.c b/auto-generated/gnu-overloaded-tests/vluxei8.c index 30d4b1f52..758413e80 100644 --- a/auto-generated/gnu-overloaded-tests/vluxei8.c +++ b/auto-generated/gnu-overloaded-tests/vluxei8.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei8_v_f16mf4(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei8_v_f16mf4(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8(rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei8_v_f16mf2(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8(rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei8_v_f16m1(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8(rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2(const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vluxei8_v_f16m2(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8(rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4(const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vluxei8_v_f16m4(const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8(rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8(const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vluxei8_v_f16m8(const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8(rs1, rs2, vl); } @@ -243,27 +243,27 @@ vuint64m8_t test_vluxei8_v_u64m8(const uint64_t *rs1, vuint8m1_t rs2, size_t vl) return __riscv_vluxei8(rs1, rs2, vl); } -vfloat16mf4_t test_vluxei8_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei8_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei8_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8(vm, rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei8_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8(vm, rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2_m(vbool8_t vm, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vluxei8_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8(vm, rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4_m(vbool4_t vm, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vluxei8_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8(vm, rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8_m(vbool2_t vm, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vluxei8_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg2ei16.c b/auto-generated/gnu-overloaded-tests/vluxseg2ei16.c index cd5a58530..47a9f286d 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg2ei16.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg2ei16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16(rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16(rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16(rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2(const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16(rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2(const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2(const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16(rs1, rs2, vl); } @@ -199,23 +199,23 @@ vuint64m4x2_t test_vluxseg2ei16_v_u64m4x2(const uint64_t *rs1, vuint16m1_t rs2, return __riscv_vluxseg2ei16(rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg2ei32.c b/auto-generated/gnu-overloaded-tests/vluxseg2ei32.c index 7412ead44..b55b75d48 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg2ei32.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg2ei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32(rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32(rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32(rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2(const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32(rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2(const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2(const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m4x2_t test_vluxseg2ei32_v_u64m4x2(const uint64_t *rs1, vuint32m2_t rs2, return __riscv_vluxseg2ei32(rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg2ei64.c b/auto-generated/gnu-overloaded-tests/vluxseg2ei64.c index 173d92829..06ec1cd09 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg2ei64.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg2ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64(rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64(rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64(rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2(const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64(rs1, rs2, vl); } @@ -171,19 +171,19 @@ vuint64m4x2_t test_vluxseg2ei64_v_u64m4x2(const uint64_t *rs1, vuint64m4_t rs2, return __riscv_vluxseg2ei64(rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg2ei8.c b/auto-generated/gnu-overloaded-tests/vluxseg2ei8.c index ebcf46f60..f861d6560 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg2ei8.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg2ei8.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8(rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8(rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8(rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2(const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8(rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2(const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2(const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8(rs1, rs2, vl); } @@ -199,23 +199,23 @@ vuint64m4x2_t test_vluxseg2ei8_v_u64m4x2(const uint64_t *rs1, vuint8mf2_t rs2, s return __riscv_vluxseg2ei8(rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg3ei16.c b/auto-generated/gnu-overloaded-tests/vluxseg3ei16.c index b8a77513a..6b74784ee 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg3ei16.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg3ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16(rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16(rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16(rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3(const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vluxseg3ei16_v_u64m2x3(const uint64_t *rs1, vuint16mf2_t rs2, return __riscv_vluxseg3ei16(rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg3ei32.c b/auto-generated/gnu-overloaded-tests/vluxseg3ei32.c index c086905e0..86c17f61f 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg3ei32.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg3ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32(rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32(rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32(rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3(const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vluxseg3ei32_v_u64m2x3(const uint64_t *rs1, vuint32m1_t rs2, return __riscv_vluxseg3ei32(rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg3ei64.c b/auto-generated/gnu-overloaded-tests/vluxseg3ei64.c index f719de855..9393c1d49 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg3ei64.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg3ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64(rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64(rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64(rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3(const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64(rs1, rs2, vl); } @@ -147,19 +147,19 @@ vuint64m2x3_t test_vluxseg3ei64_v_u64m2x3(const uint64_t *rs1, vuint64m2_t rs2, return __riscv_vluxseg3ei64(rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg3ei8.c b/auto-generated/gnu-overloaded-tests/vluxseg3ei8.c index d219273c1..8e5aae9ce 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg3ei8.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg3ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8(rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8(rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8(rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3(const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vluxseg3ei8_v_u64m2x3(const uint64_t *rs1, vuint8mf4_t rs2, s return __riscv_vluxseg3ei8(rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg4ei16.c b/auto-generated/gnu-overloaded-tests/vluxseg4ei16.c index f50911c3f..dc2c6c1b4 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg4ei16.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg4ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16(rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16(rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16(rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4(const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vluxseg4ei16_v_u64m2x4(const uint64_t *rs1, vuint16mf2_t rs2, return __riscv_vluxseg4ei16(rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg4ei32.c b/auto-generated/gnu-overloaded-tests/vluxseg4ei32.c index 51fbd8dbe..ccd4bc742 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg4ei32.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg4ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32(rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32(rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32(rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4(const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vluxseg4ei32_v_u64m2x4(const uint64_t *rs1, vuint32m1_t rs2, return __riscv_vluxseg4ei32(rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg4ei64.c b/auto-generated/gnu-overloaded-tests/vluxseg4ei64.c index 1eb2ea321..e71111336 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg4ei64.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg4ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64(rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64(rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64(rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4(const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64(rs1, rs2, vl); } @@ -147,19 +147,19 @@ vuint64m2x4_t test_vluxseg4ei64_v_u64m2x4(const uint64_t *rs1, vuint64m2_t rs2, return __riscv_vluxseg4ei64(rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg4ei8.c b/auto-generated/gnu-overloaded-tests/vluxseg4ei8.c index 80c83dbe6..ae6bb0bec 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg4ei8.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg4ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8(rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8(rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8(rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4(const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8(rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vluxseg4ei8_v_u64m2x4(const uint64_t *rs1, vuint8mf4_t rs2, s return __riscv_vluxseg4ei8(rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg5ei16.c b/auto-generated/gnu-overloaded-tests/vluxseg5ei16.c index 60918d759..e46c96ab2 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg5ei16.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg5ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16(rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16(rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vluxseg5ei16_v_u64m1x5(const uint64_t *rs1, vuint16mf4_t rs2, return __riscv_vluxseg5ei16(rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg5ei32.c b/auto-generated/gnu-overloaded-tests/vluxseg5ei32.c index a0887c47a..32a5893a1 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg5ei32.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg5ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32(rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32(rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vluxseg5ei32_v_u64m1x5(const uint64_t *rs1, vuint32mf2_t rs2, return __riscv_vluxseg5ei32(rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg5ei64.c b/auto-generated/gnu-overloaded-tests/vluxseg5ei64.c index e4d5ee470..4fcc619fa 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg5ei64.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg5ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64(rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64(rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vluxseg5ei64_v_u64m1x5(const uint64_t *rs1, vuint64m1_t rs2, return __riscv_vluxseg5ei64(rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg5ei8.c b/auto-generated/gnu-overloaded-tests/vluxseg5ei8.c index 15dcc73b3..4549edb8c 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg5ei8.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg5ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8(rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8(rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vluxseg5ei8_v_u64m1x5(const uint64_t *rs1, vuint8mf8_t rs2, s return __riscv_vluxseg5ei8(rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg6ei16.c b/auto-generated/gnu-overloaded-tests/vluxseg6ei16.c index 03914b32b..9200c5670 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg6ei16.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg6ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16(rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16(rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vluxseg6ei16_v_u64m1x6(const uint64_t *rs1, vuint16mf4_t rs2, return __riscv_vluxseg6ei16(rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg6ei32.c b/auto-generated/gnu-overloaded-tests/vluxseg6ei32.c index 41bbb7b10..03798ac70 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg6ei32.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg6ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32(rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32(rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vluxseg6ei32_v_u64m1x6(const uint64_t *rs1, vuint32mf2_t rs2, return __riscv_vluxseg6ei32(rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg6ei64.c b/auto-generated/gnu-overloaded-tests/vluxseg6ei64.c index 55c27f783..e0525aa3b 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg6ei64.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg6ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64(rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64(rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vluxseg6ei64_v_u64m1x6(const uint64_t *rs1, vuint64m1_t rs2, return __riscv_vluxseg6ei64(rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg6ei8.c b/auto-generated/gnu-overloaded-tests/vluxseg6ei8.c index d884c02b4..4439b0aeb 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg6ei8.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg6ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8(rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8(rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vluxseg6ei8_v_u64m1x6(const uint64_t *rs1, vuint8mf8_t rs2, s return __riscv_vluxseg6ei8(rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg7ei16.c b/auto-generated/gnu-overloaded-tests/vluxseg7ei16.c index 2fe4aa0de..b75f32d65 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg7ei16.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg7ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16(rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16(rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vluxseg7ei16_v_u64m1x7(const uint64_t *rs1, vuint16mf4_t rs2, return __riscv_vluxseg7ei16(rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg7ei32.c b/auto-generated/gnu-overloaded-tests/vluxseg7ei32.c index eefa2e87b..6b6b1997b 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg7ei32.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg7ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32(rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32(rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vluxseg7ei32_v_u64m1x7(const uint64_t *rs1, vuint32mf2_t rs2, return __riscv_vluxseg7ei32(rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg7ei64.c b/auto-generated/gnu-overloaded-tests/vluxseg7ei64.c index d63d83152..de5a7ac27 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg7ei64.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg7ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64(rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64(rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vluxseg7ei64_v_u64m1x7(const uint64_t *rs1, vuint64m1_t rs2, return __riscv_vluxseg7ei64(rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg7ei8.c b/auto-generated/gnu-overloaded-tests/vluxseg7ei8.c index f7d06d3af..0c94bb473 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg7ei8.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg7ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8(rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8(rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vluxseg7ei8_v_u64m1x7(const uint64_t *rs1, vuint8mf8_t rs2, s return __riscv_vluxseg7ei8(rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg8ei16.c b/auto-generated/gnu-overloaded-tests/vluxseg8ei16.c index 471d6484d..64c6d12e8 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg8ei16.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg8ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8(const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16(rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8(const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16(rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8(const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vluxseg8ei16_v_u64m1x8(const uint64_t *rs1, vuint16mf4_t rs2, return __riscv_vluxseg8ei16(rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg8ei32.c b/auto-generated/gnu-overloaded-tests/vluxseg8ei32.c index dc63d39bf..c25d1f7ba 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg8ei32.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg8ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8(const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32(rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8(const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32(rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8(const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vluxseg8ei32_v_u64m1x8(const uint64_t *rs1, vuint32mf2_t rs2, return __riscv_vluxseg8ei32(rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg8ei64.c b/auto-generated/gnu-overloaded-tests/vluxseg8ei64.c index 0efb5ff3f..3682765e1 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg8ei64.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg8ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8(const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64(rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8(const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64(rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8(const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vluxseg8ei64_v_u64m1x8(const uint64_t *rs1, vuint64m1_t rs2, return __riscv_vluxseg8ei64(rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vluxseg8ei8.c b/auto-generated/gnu-overloaded-tests/vluxseg8ei8.c index 44e6ec368..18221d62a 100644 --- a/auto-generated/gnu-overloaded-tests/vluxseg8ei8.c +++ b/auto-generated/gnu-overloaded-tests/vluxseg8ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8(const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8(const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8(rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8(const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8(rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vluxseg8ei8_v_u64m1x8(const uint64_t *rs1, vuint8mf8_t rs2, s return __riscv_vluxseg8ei8(rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vse16.c b/auto-generated/gnu-overloaded-tests/vse16.c index 948b3652d..6eb2a14c9 100644 --- a/auto-generated/gnu-overloaded-tests/vse16.c +++ b/auto-generated/gnu-overloaded-tests/vse16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vse16_v_f16mf4(float16_t *rs1, vfloat16mf4_t vs3, size_t vl) { +void test_vse16_v_f16mf4(_Float16 *rs1, vfloat16mf4_t vs3, size_t vl) { return __riscv_vse16(rs1, vs3, vl); } -void test_vse16_v_f16mf2(float16_t *rs1, vfloat16mf2_t vs3, size_t vl) { +void test_vse16_v_f16mf2(_Float16 *rs1, vfloat16mf2_t vs3, size_t vl) { return __riscv_vse16(rs1, vs3, vl); } -void test_vse16_v_f16m1(float16_t *rs1, vfloat16m1_t vs3, size_t vl) { +void test_vse16_v_f16m1(_Float16 *rs1, vfloat16m1_t vs3, size_t vl) { return __riscv_vse16(rs1, vs3, vl); } -void test_vse16_v_f16m2(float16_t *rs1, vfloat16m2_t vs3, size_t vl) { +void test_vse16_v_f16m2(_Float16 *rs1, vfloat16m2_t vs3, size_t vl) { return __riscv_vse16(rs1, vs3, vl); } -void test_vse16_v_f16m4(float16_t *rs1, vfloat16m4_t vs3, size_t vl) { +void test_vse16_v_f16m4(_Float16 *rs1, vfloat16m4_t vs3, size_t vl) { return __riscv_vse16(rs1, vs3, vl); } -void test_vse16_v_f16m8(float16_t *rs1, vfloat16m8_t vs3, size_t vl) { +void test_vse16_v_f16m8(_Float16 *rs1, vfloat16m8_t vs3, size_t vl) { return __riscv_vse16(rs1, vs3, vl); } @@ -79,27 +79,27 @@ void test_vse16_v_u16m8(uint16_t *rs1, vuint16m8_t vs3, size_t vl) { return __riscv_vse16(rs1, vs3, vl); } -void test_vse16_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vfloat16mf4_t vs3, size_t vl) { +void test_vse16_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4_t vs3, size_t vl) { return __riscv_vse16(vm, rs1, vs3, vl); } -void test_vse16_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vfloat16mf2_t vs3, size_t vl) { +void test_vse16_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2_t vs3, size_t vl) { return __riscv_vse16(vm, rs1, vs3, vl); } -void test_vse16_v_f16m1_m(vbool16_t vm, float16_t *rs1, vfloat16m1_t vs3, size_t vl) { +void test_vse16_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vfloat16m1_t vs3, size_t vl) { return __riscv_vse16(vm, rs1, vs3, vl); } -void test_vse16_v_f16m2_m(vbool8_t vm, float16_t *rs1, vfloat16m2_t vs3, size_t vl) { +void test_vse16_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vfloat16m2_t vs3, size_t vl) { return __riscv_vse16(vm, rs1, vs3, vl); } -void test_vse16_v_f16m4_m(vbool4_t vm, float16_t *rs1, vfloat16m4_t vs3, size_t vl) { +void test_vse16_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vfloat16m4_t vs3, size_t vl) { return __riscv_vse16(vm, rs1, vs3, vl); } -void test_vse16_v_f16m8_m(vbool2_t vm, float16_t *rs1, vfloat16m8_t vs3, size_t vl) { +void test_vse16_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vfloat16m8_t vs3, size_t vl) { return __riscv_vse16(vm, rs1, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxei16.c b/auto-generated/gnu-overloaded-tests/vsoxei16.c index e9ad11a76..1f2044656 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxei16.c +++ b/auto-generated/gnu-overloaded-tests/vsoxei16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxei16_v_f16mf4(float16_t *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsoxei16_v_f16mf4(_Float16 *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei16(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16mf2(float16_t *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsoxei16_v_f16mf2(_Float16 *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei16(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m1(float16_t *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsoxei16_v_f16m1(_Float16 *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei16(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m2(float16_t *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsoxei16_v_f16m2(_Float16 *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei16(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m4(float16_t *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsoxei16_v_f16m4(_Float16 *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei16(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m8(float16_t *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsoxei16_v_f16m8(_Float16 *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsoxei16(rs1, rs2, vs3, vl); } @@ -235,27 +235,27 @@ void test_vsoxei16_v_u64m8(uint64_t *rs1, vuint16m2_t rs2, vuint64m8_t vs3, size return __riscv_vsoxei16(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsoxei16_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei16(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsoxei16_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei16(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsoxei16_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei16(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsoxei16_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei16(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsoxei16_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei16(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m8_m(vbool2_t vm, float16_t *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsoxei16_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsoxei16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxei32.c b/auto-generated/gnu-overloaded-tests/vsoxei32.c index 3a1021dca..915b4f4cd 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxei32.c +++ b/auto-generated/gnu-overloaded-tests/vsoxei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxei32_v_f16mf4(float16_t *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsoxei32_v_f16mf4(_Float16 *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei32(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16mf2(float16_t *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsoxei32_v_f16mf2(_Float16 *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei32(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m1(float16_t *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsoxei32_v_f16m1(_Float16 *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei32(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m2(float16_t *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsoxei32_v_f16m2(_Float16 *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei32(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m4(float16_t *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsoxei32_v_f16m4(_Float16 *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei32(rs1, rs2, vs3, vl); } @@ -215,23 +215,23 @@ void test_vsoxei32_v_u64m8(uint64_t *rs1, vuint32m4_t rs2, vuint64m8_t vs3, size return __riscv_vsoxei32(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsoxei32_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei32(vm, rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsoxei32_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei32(vm, rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsoxei32_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei32(vm, rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsoxei32_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei32(vm, rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsoxei32_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei32(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxei64.c b/auto-generated/gnu-overloaded-tests/vsoxei64.c index a67a3fc43..719d38c13 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxei64.c +++ b/auto-generated/gnu-overloaded-tests/vsoxei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxei64_v_f16mf4(float16_t *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsoxei64_v_f16mf4(_Float16 *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei64(rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16mf2(float16_t *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsoxei64_v_f16mf2(_Float16 *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei64(rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16m1(float16_t *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsoxei64_v_f16m1(_Float16 *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei64(rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16m2(float16_t *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsoxei64_v_f16m2(_Float16 *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei64(rs1, rs2, vs3, vl); } @@ -183,19 +183,19 @@ void test_vsoxei64_v_u64m8(uint64_t *rs1, vuint64m8_t rs2, vuint64m8_t vs3, size return __riscv_vsoxei64(rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsoxei64_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei64(vm, rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsoxei64_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei64(vm, rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsoxei64_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei64(vm, rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsoxei64_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei64(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxei8.c b/auto-generated/gnu-overloaded-tests/vsoxei8.c index 5673eb0e7..b9e3ebde9 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxei8.c +++ b/auto-generated/gnu-overloaded-tests/vsoxei8.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxei8_v_f16mf4(float16_t *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsoxei8_v_f16mf4(_Float16 *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei8(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16mf2(float16_t *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsoxei8_v_f16mf2(_Float16 *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei8(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m1(float16_t *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsoxei8_v_f16m1(_Float16 *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei8(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m2(float16_t *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsoxei8_v_f16m2(_Float16 *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei8(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m4(float16_t *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsoxei8_v_f16m4(_Float16 *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei8(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m8(float16_t *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsoxei8_v_f16m8(_Float16 *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsoxei8(rs1, rs2, vs3, vl); } @@ -243,27 +243,27 @@ void test_vsoxei8_v_u64m8(uint64_t *rs1, vuint8m1_t rs2, vuint64m8_t vs3, size_t return __riscv_vsoxei8(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsoxei8_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei8(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsoxei8_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei8(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsoxei8_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei8(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsoxei8_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei8(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsoxei8_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei8(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m8_m(vbool2_t vm, float16_t *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsoxei8_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsoxei8(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg2ei16.c b/auto-generated/gnu-overloaded-tests/vsoxseg2ei16.c index a3510e300..3ecd1a64f 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg2ei16.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg2ei16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg2ei16_v_f16mf4x2(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16mf4x2(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16mf2x2(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16mf2x2(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m1x2(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16m1x2(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m2x2(float16_t *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16m2x2(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m4x2(float16_t *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16m4x2(_Float16 *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(rs1, vs2, vs3, vl); } @@ -199,23 +199,23 @@ void test_vsoxseg2ei16_v_u64m4x2(uint64_t *rs1, vuint16m1_t vs2, vuint64m4x2_t v return __riscv_vsoxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsoxseg2ei16_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg2ei32.c b/auto-generated/gnu-overloaded-tests/vsoxseg2ei32.c index 6933e2260..830f87727 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg2ei32.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg2ei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg2ei32_v_f16mf4x2(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16mf4x2(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16mf2x2(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16mf2x2(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m1x2(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16m1x2(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m2x2(float16_t *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16m2x2(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m4x2(float16_t *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16m4x2(_Float16 *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(rs1, vs2, vs3, vl); } @@ -191,23 +191,23 @@ void test_vsoxseg2ei32_v_u64m4x2(uint64_t *rs1, vuint32m2_t vs2, vuint64m4x2_t v return __riscv_vsoxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsoxseg2ei32_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg2ei64.c b/auto-generated/gnu-overloaded-tests/vsoxseg2ei64.c index 89c1a4656..6d4299123 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg2ei64.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg2ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg2ei64_v_f16mf4x2(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsoxseg2ei64_v_f16mf4x2(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16mf2x2(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsoxseg2ei64_v_f16mf2x2(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16m1x2(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsoxseg2ei64_v_f16m1x2(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16m2x2(float16_t *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsoxseg2ei64_v_f16m2x2(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64(rs1, vs2, vs3, vl); } @@ -171,19 +171,19 @@ void test_vsoxseg2ei64_v_u64m4x2(uint64_t *rs1, vuint64m4_t vs2, vuint64m4x2_t v return __riscv_vsoxseg2ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsoxseg2ei64_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsoxseg2ei64_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsoxseg2ei64_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsoxseg2ei64_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg2ei8.c b/auto-generated/gnu-overloaded-tests/vsoxseg2ei8.c index 06b906eca..f292466c7 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg2ei8.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg2ei8.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg2ei8_v_f16mf4x2(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16mf4x2(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16mf2x2(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16mf2x2(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m1x2(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16m1x2(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m2x2(float16_t *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16m2x2(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m4x2(float16_t *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16m4x2(_Float16 *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(rs1, vs2, vs3, vl); } @@ -199,23 +199,23 @@ void test_vsoxseg2ei8_v_u64m4x2(uint64_t *rs1, vuint8mf2_t vs2, vuint64m4x2_t vs return __riscv_vsoxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsoxseg2ei8_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg3ei16.c b/auto-generated/gnu-overloaded-tests/vsoxseg3ei16.c index ab7fe7a72..3da0af74d 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg3ei16.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg3ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg3ei16_v_f16mf4x3(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsoxseg3ei16_v_f16mf4x3(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16mf2x3(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsoxseg3ei16_v_f16mf2x3(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16m1x3(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsoxseg3ei16_v_f16m1x3(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16m2x3(float16_t *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsoxseg3ei16_v_f16m2x3(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsoxseg3ei16_v_u64m2x3(uint64_t *rs1, vuint16mf2_t vs2, vuint64m2x3_t return __riscv_vsoxseg3ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsoxseg3ei16_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsoxseg3ei16_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsoxseg3ei16_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsoxseg3ei16_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg3ei32.c b/auto-generated/gnu-overloaded-tests/vsoxseg3ei32.c index 8ac97b30e..3501afdf5 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg3ei32.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg3ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg3ei32_v_f16mf4x3(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsoxseg3ei32_v_f16mf4x3(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16mf2x3(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsoxseg3ei32_v_f16mf2x3(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16m1x3(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsoxseg3ei32_v_f16m1x3(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16m2x3(float16_t *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsoxseg3ei32_v_f16m2x3(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsoxseg3ei32_v_u64m2x3(uint64_t *rs1, vuint32m1_t vs2, vuint64m2x3_t v return __riscv_vsoxseg3ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsoxseg3ei32_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsoxseg3ei32_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsoxseg3ei32_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsoxseg3ei32_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg3ei64.c b/auto-generated/gnu-overloaded-tests/vsoxseg3ei64.c index f9c33ba78..7c3bde400 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg3ei64.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg3ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg3ei64_v_f16mf4x3(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsoxseg3ei64_v_f16mf4x3(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16mf2x3(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsoxseg3ei64_v_f16mf2x3(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16m1x3(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsoxseg3ei64_v_f16m1x3(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16m2x3(float16_t *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsoxseg3ei64_v_f16m2x3(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64(rs1, vs2, vs3, vl); } @@ -147,19 +147,19 @@ void test_vsoxseg3ei64_v_u64m2x3(uint64_t *rs1, vuint64m2_t vs2, vuint64m2x3_t v return __riscv_vsoxseg3ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsoxseg3ei64_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsoxseg3ei64_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsoxseg3ei64_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsoxseg3ei64_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg3ei8.c b/auto-generated/gnu-overloaded-tests/vsoxseg3ei8.c index 8955016a6..d6d47ec5c 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg3ei8.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg3ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg3ei8_v_f16mf4x3(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsoxseg3ei8_v_f16mf4x3(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16mf2x3(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsoxseg3ei8_v_f16mf2x3(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16m1x3(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsoxseg3ei8_v_f16m1x3(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16m2x3(float16_t *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsoxseg3ei8_v_f16m2x3(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsoxseg3ei8_v_u64m2x3(uint64_t *rs1, vuint8mf4_t vs2, vuint64m2x3_t vs return __riscv_vsoxseg3ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsoxseg3ei8_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsoxseg3ei8_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsoxseg3ei8_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsoxseg3ei8_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg4ei16.c b/auto-generated/gnu-overloaded-tests/vsoxseg4ei16.c index 9aebd8444..65b56ee30 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg4ei16.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg4ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg4ei16_v_f16mf4x4(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsoxseg4ei16_v_f16mf4x4(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16mf2x4(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsoxseg4ei16_v_f16mf2x4(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16m1x4(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsoxseg4ei16_v_f16m1x4(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16m2x4(float16_t *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsoxseg4ei16_v_f16m2x4(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsoxseg4ei16_v_u64m2x4(uint64_t *rs1, vuint16mf2_t vs2, vuint64m2x4_t return __riscv_vsoxseg4ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsoxseg4ei16_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsoxseg4ei16_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsoxseg4ei16_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsoxseg4ei16_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg4ei32.c b/auto-generated/gnu-overloaded-tests/vsoxseg4ei32.c index 98a5e2960..7d4c2fba0 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg4ei32.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg4ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg4ei32_v_f16mf4x4(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsoxseg4ei32_v_f16mf4x4(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16mf2x4(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsoxseg4ei32_v_f16mf2x4(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16m1x4(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsoxseg4ei32_v_f16m1x4(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16m2x4(float16_t *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsoxseg4ei32_v_f16m2x4(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsoxseg4ei32_v_u64m2x4(uint64_t *rs1, vuint32m1_t vs2, vuint64m2x4_t v return __riscv_vsoxseg4ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsoxseg4ei32_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsoxseg4ei32_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsoxseg4ei32_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsoxseg4ei32_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg4ei64.c b/auto-generated/gnu-overloaded-tests/vsoxseg4ei64.c index be28eab7b..837014a76 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg4ei64.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg4ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg4ei64_v_f16mf4x4(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsoxseg4ei64_v_f16mf4x4(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16mf2x4(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsoxseg4ei64_v_f16mf2x4(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16m1x4(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsoxseg4ei64_v_f16m1x4(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16m2x4(float16_t *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsoxseg4ei64_v_f16m2x4(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64(rs1, vs2, vs3, vl); } @@ -147,19 +147,19 @@ void test_vsoxseg4ei64_v_u64m2x4(uint64_t *rs1, vuint64m2_t vs2, vuint64m2x4_t v return __riscv_vsoxseg4ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsoxseg4ei64_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsoxseg4ei64_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsoxseg4ei64_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsoxseg4ei64_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg4ei8.c b/auto-generated/gnu-overloaded-tests/vsoxseg4ei8.c index bf7a5779c..0ba7ae2e9 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg4ei8.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg4ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg4ei8_v_f16mf4x4(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsoxseg4ei8_v_f16mf4x4(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16mf2x4(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsoxseg4ei8_v_f16mf2x4(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16m1x4(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsoxseg4ei8_v_f16m1x4(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16m2x4(float16_t *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsoxseg4ei8_v_f16m2x4(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsoxseg4ei8_v_u64m2x4(uint64_t *rs1, vuint8mf4_t vs2, vuint64m2x4_t vs return __riscv_vsoxseg4ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsoxseg4ei8_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsoxseg4ei8_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsoxseg4ei8_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsoxseg4ei8_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg5ei16.c b/auto-generated/gnu-overloaded-tests/vsoxseg5ei16.c index 21feee9fb..fbaf01a86 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg5ei16.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg5ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg5ei16_v_f16mf4x5(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsoxseg5ei16_v_f16mf4x5(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16mf2x5(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsoxseg5ei16_v_f16mf2x5(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16m1x5(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsoxseg5ei16_v_f16m1x5(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg5ei16_v_u64m1x5(uint64_t *rs1, vuint16mf4_t vs2, vuint64m1x5_t return __riscv_vsoxseg5ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsoxseg5ei16_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsoxseg5ei16_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsoxseg5ei16_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg5ei32.c b/auto-generated/gnu-overloaded-tests/vsoxseg5ei32.c index 9ec0f4ea9..91800dacf 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg5ei32.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg5ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg5ei32_v_f16mf4x5(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsoxseg5ei32_v_f16mf4x5(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16mf2x5(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsoxseg5ei32_v_f16mf2x5(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16m1x5(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsoxseg5ei32_v_f16m1x5(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg5ei32_v_u64m1x5(uint64_t *rs1, vuint32mf2_t vs2, vuint64m1x5_t return __riscv_vsoxseg5ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsoxseg5ei32_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsoxseg5ei32_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsoxseg5ei32_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg5ei64.c b/auto-generated/gnu-overloaded-tests/vsoxseg5ei64.c index 9532a8b19..0a4b343a0 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg5ei64.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg5ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg5ei64_v_f16mf4x5(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsoxseg5ei64_v_f16mf4x5(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16mf2x5(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsoxseg5ei64_v_f16mf2x5(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16m1x5(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsoxseg5ei64_v_f16m1x5(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg5ei64_v_u64m1x5(uint64_t *rs1, vuint64m1_t vs2, vuint64m1x5_t v return __riscv_vsoxseg5ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsoxseg5ei64_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsoxseg5ei64_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsoxseg5ei64_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg5ei8.c b/auto-generated/gnu-overloaded-tests/vsoxseg5ei8.c index 8fe8d0af0..95892b58d 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg5ei8.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg5ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg5ei8_v_f16mf4x5(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsoxseg5ei8_v_f16mf4x5(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16mf2x5(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsoxseg5ei8_v_f16mf2x5(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16m1x5(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsoxseg5ei8_v_f16m1x5(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg5ei8_v_u64m1x5(uint64_t *rs1, vuint8mf8_t vs2, vuint64m1x5_t vs return __riscv_vsoxseg5ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsoxseg5ei8_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsoxseg5ei8_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsoxseg5ei8_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg6ei16.c b/auto-generated/gnu-overloaded-tests/vsoxseg6ei16.c index 2712cbe4f..511ed97fb 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg6ei16.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg6ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg6ei16_v_f16mf4x6(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsoxseg6ei16_v_f16mf4x6(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16mf2x6(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsoxseg6ei16_v_f16mf2x6(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16m1x6(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsoxseg6ei16_v_f16m1x6(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg6ei16_v_u64m1x6(uint64_t *rs1, vuint16mf4_t vs2, vuint64m1x6_t return __riscv_vsoxseg6ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsoxseg6ei16_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsoxseg6ei16_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsoxseg6ei16_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg6ei32.c b/auto-generated/gnu-overloaded-tests/vsoxseg6ei32.c index f49c4db8b..5316b5216 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg6ei32.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg6ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg6ei32_v_f16mf4x6(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsoxseg6ei32_v_f16mf4x6(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16mf2x6(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsoxseg6ei32_v_f16mf2x6(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16m1x6(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsoxseg6ei32_v_f16m1x6(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg6ei32_v_u64m1x6(uint64_t *rs1, vuint32mf2_t vs2, vuint64m1x6_t return __riscv_vsoxseg6ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsoxseg6ei32_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsoxseg6ei32_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsoxseg6ei32_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg6ei64.c b/auto-generated/gnu-overloaded-tests/vsoxseg6ei64.c index 5a3eae349..fcba47c94 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg6ei64.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg6ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg6ei64_v_f16mf4x6(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsoxseg6ei64_v_f16mf4x6(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16mf2x6(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsoxseg6ei64_v_f16mf2x6(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16m1x6(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsoxseg6ei64_v_f16m1x6(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg6ei64_v_u64m1x6(uint64_t *rs1, vuint64m1_t vs2, vuint64m1x6_t v return __riscv_vsoxseg6ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsoxseg6ei64_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsoxseg6ei64_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsoxseg6ei64_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg6ei8.c b/auto-generated/gnu-overloaded-tests/vsoxseg6ei8.c index c51b81551..843b67c07 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg6ei8.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg6ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg6ei8_v_f16mf4x6(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsoxseg6ei8_v_f16mf4x6(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16mf2x6(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsoxseg6ei8_v_f16mf2x6(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16m1x6(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsoxseg6ei8_v_f16m1x6(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg6ei8_v_u64m1x6(uint64_t *rs1, vuint8mf8_t vs2, vuint64m1x6_t vs return __riscv_vsoxseg6ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsoxseg6ei8_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsoxseg6ei8_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsoxseg6ei8_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg7ei16.c b/auto-generated/gnu-overloaded-tests/vsoxseg7ei16.c index 939625606..f48c62c8d 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg7ei16.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg7ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg7ei16_v_f16mf4x7(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsoxseg7ei16_v_f16mf4x7(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16mf2x7(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsoxseg7ei16_v_f16mf2x7(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16m1x7(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsoxseg7ei16_v_f16m1x7(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg7ei16_v_u64m1x7(uint64_t *rs1, vuint16mf4_t vs2, vuint64m1x7_t return __riscv_vsoxseg7ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsoxseg7ei16_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsoxseg7ei16_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsoxseg7ei16_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg7ei32.c b/auto-generated/gnu-overloaded-tests/vsoxseg7ei32.c index f8e110fd4..b5e39b596 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg7ei32.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg7ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg7ei32_v_f16mf4x7(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsoxseg7ei32_v_f16mf4x7(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16mf2x7(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsoxseg7ei32_v_f16mf2x7(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16m1x7(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsoxseg7ei32_v_f16m1x7(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg7ei32_v_u64m1x7(uint64_t *rs1, vuint32mf2_t vs2, vuint64m1x7_t return __riscv_vsoxseg7ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsoxseg7ei32_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsoxseg7ei32_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsoxseg7ei32_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg7ei64.c b/auto-generated/gnu-overloaded-tests/vsoxseg7ei64.c index b68f829e1..072e0a267 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg7ei64.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg7ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg7ei64_v_f16mf4x7(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsoxseg7ei64_v_f16mf4x7(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16mf2x7(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsoxseg7ei64_v_f16mf2x7(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16m1x7(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsoxseg7ei64_v_f16m1x7(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg7ei64_v_u64m1x7(uint64_t *rs1, vuint64m1_t vs2, vuint64m1x7_t v return __riscv_vsoxseg7ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsoxseg7ei64_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsoxseg7ei64_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsoxseg7ei64_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg7ei8.c b/auto-generated/gnu-overloaded-tests/vsoxseg7ei8.c index be6d84467..0479c92fd 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg7ei8.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg7ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg7ei8_v_f16mf4x7(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsoxseg7ei8_v_f16mf4x7(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16mf2x7(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsoxseg7ei8_v_f16mf2x7(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16m1x7(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsoxseg7ei8_v_f16m1x7(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg7ei8_v_u64m1x7(uint64_t *rs1, vuint8mf8_t vs2, vuint64m1x7_t vs return __riscv_vsoxseg7ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsoxseg7ei8_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsoxseg7ei8_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsoxseg7ei8_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg8ei16.c b/auto-generated/gnu-overloaded-tests/vsoxseg8ei16.c index 372bb6c09..bd43f4365 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg8ei16.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg8ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg8ei16_v_f16mf4x8(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsoxseg8ei16_v_f16mf4x8(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16mf2x8(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsoxseg8ei16_v_f16mf2x8(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16m1x8(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsoxseg8ei16_v_f16m1x8(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg8ei16_v_u64m1x8(uint64_t *rs1, vuint16mf4_t vs2, vuint64m1x8_t return __riscv_vsoxseg8ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsoxseg8ei16_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsoxseg8ei16_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsoxseg8ei16_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg8ei32.c b/auto-generated/gnu-overloaded-tests/vsoxseg8ei32.c index 88f0fda38..892c2f814 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg8ei32.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg8ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg8ei32_v_f16mf4x8(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsoxseg8ei32_v_f16mf4x8(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16mf2x8(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsoxseg8ei32_v_f16mf2x8(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16m1x8(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsoxseg8ei32_v_f16m1x8(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg8ei32_v_u64m1x8(uint64_t *rs1, vuint32mf2_t vs2, vuint64m1x8_t return __riscv_vsoxseg8ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsoxseg8ei32_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsoxseg8ei32_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsoxseg8ei32_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg8ei64.c b/auto-generated/gnu-overloaded-tests/vsoxseg8ei64.c index fe00ca51a..a4c264bce 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg8ei64.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg8ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg8ei64_v_f16mf4x8(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsoxseg8ei64_v_f16mf4x8(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16mf2x8(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsoxseg8ei64_v_f16mf2x8(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16m1x8(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsoxseg8ei64_v_f16m1x8(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg8ei64_v_u64m1x8(uint64_t *rs1, vuint64m1_t vs2, vuint64m1x8_t v return __riscv_vsoxseg8ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsoxseg8ei64_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsoxseg8ei64_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsoxseg8ei64_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsoxseg8ei8.c b/auto-generated/gnu-overloaded-tests/vsoxseg8ei8.c index d0dde1dc7..96cc1b8a9 100644 --- a/auto-generated/gnu-overloaded-tests/vsoxseg8ei8.c +++ b/auto-generated/gnu-overloaded-tests/vsoxseg8ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg8ei8_v_f16mf4x8(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsoxseg8ei8_v_f16mf4x8(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16mf2x8(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsoxseg8ei8_v_f16mf2x8(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16m1x8(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsoxseg8ei8_v_f16m1x8(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsoxseg8ei8_v_u64m1x8(uint64_t *rs1, vuint8mf8_t vs2, vuint64m1x8_t vs return __riscv_vsoxseg8ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsoxseg8ei8_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsoxseg8ei8_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsoxseg8ei8_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsse16.c b/auto-generated/gnu-overloaded-tests/vsse16.c index 583939436..80c6a81b6 100644 --- a/auto-generated/gnu-overloaded-tests/vsse16.c +++ b/auto-generated/gnu-overloaded-tests/vsse16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsse16_v_f16mf4(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsse16_v_f16mf4(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsse16(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16mf2(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsse16_v_f16mf2(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsse16(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m1(float16_t *rs1, ptrdiff_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsse16_v_f16m1(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsse16(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m2(float16_t *rs1, ptrdiff_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsse16_v_f16m2(_Float16 *rs1, ptrdiff_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsse16(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m4(float16_t *rs1, ptrdiff_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsse16_v_f16m4(_Float16 *rs1, ptrdiff_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsse16(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m8(float16_t *rs1, ptrdiff_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsse16_v_f16m8(_Float16 *rs1, ptrdiff_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsse16(rs1, rs2, vs3, vl); } @@ -79,27 +79,27 @@ void test_vsse16_v_u16m8(uint16_t *rs1, ptrdiff_t rs2, vuint16m8_t vs3, size_t v return __riscv_vsse16(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16mf4_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsse16_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsse16(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16mf2_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsse16_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsse16(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m1_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsse16_v_f16m1_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsse16(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m2_m(vbool8_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsse16_v_f16m2_m(vbool8_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsse16(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m4_m(vbool4_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsse16_v_f16m4_m(vbool4_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsse16(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m8_m(vbool2_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsse16_v_f16m8_m(vbool2_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsse16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsseg2e16.c b/auto-generated/gnu-overloaded-tests/vsseg2e16.c index 3616802d9..34a8d37f3 100644 --- a/auto-generated/gnu-overloaded-tests/vsseg2e16.c +++ b/auto-generated/gnu-overloaded-tests/vsseg2e16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg2e16_v_f16mf4x2(float16_t *rs1, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16mf4x2(_Float16 *rs1, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsseg2e16(rs1, vs3, vl); } -void test_vsseg2e16_v_f16mf2x2(float16_t *rs1, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16mf2x2(_Float16 *rs1, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsseg2e16(rs1, vs3, vl); } -void test_vsseg2e16_v_f16m1x2(float16_t *rs1, vfloat16m1x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m1x2(_Float16 *rs1, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsseg2e16(rs1, vs3, vl); } -void test_vsseg2e16_v_f16m2x2(float16_t *rs1, vfloat16m2x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m2x2(_Float16 *rs1, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsseg2e16(rs1, vs3, vl); } -void test_vsseg2e16_v_f16m4x2(float16_t *rs1, vfloat16m4x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m4x2(_Float16 *rs1, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsseg2e16(rs1, vs3, vl); } @@ -67,23 +67,23 @@ void test_vsseg2e16_v_u16m4x2(uint16_t *rs1, vuint16m4x2_t vs3, size_t vl) { return __riscv_vsseg2e16(rs1, vs3, vl); } -void test_vsseg2e16_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsseg2e16(vm, rs1, vs3, vl); } -void test_vsseg2e16_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsseg2e16(vm, rs1, vs3, vl); } -void test_vsseg2e16_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vfloat16m1x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsseg2e16(vm, rs1, vs3, vl); } -void test_vsseg2e16_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vfloat16m2x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsseg2e16(vm, rs1, vs3, vl); } -void test_vsseg2e16_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vfloat16m4x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsseg2e16(vm, rs1, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsseg3e16.c b/auto-generated/gnu-overloaded-tests/vsseg3e16.c index 9e609aa69..a10d48330 100644 --- a/auto-generated/gnu-overloaded-tests/vsseg3e16.c +++ b/auto-generated/gnu-overloaded-tests/vsseg3e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg3e16_v_f16mf4x3(float16_t *rs1, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16mf4x3(_Float16 *rs1, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsseg3e16(rs1, vs3, vl); } -void test_vsseg3e16_v_f16mf2x3(float16_t *rs1, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16mf2x3(_Float16 *rs1, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsseg3e16(rs1, vs3, vl); } -void test_vsseg3e16_v_f16m1x3(float16_t *rs1, vfloat16m1x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16m1x3(_Float16 *rs1, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsseg3e16(rs1, vs3, vl); } -void test_vsseg3e16_v_f16m2x3(float16_t *rs1, vfloat16m2x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16m2x3(_Float16 *rs1, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsseg3e16(rs1, vs3, vl); } @@ -55,19 +55,19 @@ void test_vsseg3e16_v_u16m2x3(uint16_t *rs1, vuint16m2x3_t vs3, size_t vl) { return __riscv_vsseg3e16(rs1, vs3, vl); } -void test_vsseg3e16_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsseg3e16(vm, rs1, vs3, vl); } -void test_vsseg3e16_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsseg3e16(vm, rs1, vs3, vl); } -void test_vsseg3e16_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vfloat16m1x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsseg3e16(vm, rs1, vs3, vl); } -void test_vsseg3e16_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vfloat16m2x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsseg3e16(vm, rs1, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsseg4e16.c b/auto-generated/gnu-overloaded-tests/vsseg4e16.c index 4ff35d176..9ad7781c2 100644 --- a/auto-generated/gnu-overloaded-tests/vsseg4e16.c +++ b/auto-generated/gnu-overloaded-tests/vsseg4e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg4e16_v_f16mf4x4(float16_t *rs1, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16mf4x4(_Float16 *rs1, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsseg4e16(rs1, vs3, vl); } -void test_vsseg4e16_v_f16mf2x4(float16_t *rs1, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16mf2x4(_Float16 *rs1, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsseg4e16(rs1, vs3, vl); } -void test_vsseg4e16_v_f16m1x4(float16_t *rs1, vfloat16m1x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16m1x4(_Float16 *rs1, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsseg4e16(rs1, vs3, vl); } -void test_vsseg4e16_v_f16m2x4(float16_t *rs1, vfloat16m2x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16m2x4(_Float16 *rs1, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsseg4e16(rs1, vs3, vl); } @@ -55,19 +55,19 @@ void test_vsseg4e16_v_u16m2x4(uint16_t *rs1, vuint16m2x4_t vs3, size_t vl) { return __riscv_vsseg4e16(rs1, vs3, vl); } -void test_vsseg4e16_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsseg4e16(vm, rs1, vs3, vl); } -void test_vsseg4e16_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsseg4e16(vm, rs1, vs3, vl); } -void test_vsseg4e16_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vfloat16m1x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsseg4e16(vm, rs1, vs3, vl); } -void test_vsseg4e16_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vfloat16m2x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsseg4e16(vm, rs1, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsseg5e16.c b/auto-generated/gnu-overloaded-tests/vsseg5e16.c index 8c70320b9..da674d1f6 100644 --- a/auto-generated/gnu-overloaded-tests/vsseg5e16.c +++ b/auto-generated/gnu-overloaded-tests/vsseg5e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg5e16_v_f16mf4x5(float16_t *rs1, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16mf4x5(_Float16 *rs1, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsseg5e16(rs1, vs3, vl); } -void test_vsseg5e16_v_f16mf2x5(float16_t *rs1, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16mf2x5(_Float16 *rs1, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsseg5e16(rs1, vs3, vl); } -void test_vsseg5e16_v_f16m1x5(float16_t *rs1, vfloat16m1x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16m1x5(_Float16 *rs1, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsseg5e16(rs1, vs3, vl); } @@ -43,15 +43,15 @@ void test_vsseg5e16_v_u16m1x5(uint16_t *rs1, vuint16m1x5_t vs3, size_t vl) { return __riscv_vsseg5e16(rs1, vs3, vl); } -void test_vsseg5e16_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsseg5e16(vm, rs1, vs3, vl); } -void test_vsseg5e16_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsseg5e16(vm, rs1, vs3, vl); } -void test_vsseg5e16_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vfloat16m1x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsseg5e16(vm, rs1, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsseg6e16.c b/auto-generated/gnu-overloaded-tests/vsseg6e16.c index 9fd2e0db4..66d0c7209 100644 --- a/auto-generated/gnu-overloaded-tests/vsseg6e16.c +++ b/auto-generated/gnu-overloaded-tests/vsseg6e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg6e16_v_f16mf4x6(float16_t *rs1, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16mf4x6(_Float16 *rs1, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsseg6e16(rs1, vs3, vl); } -void test_vsseg6e16_v_f16mf2x6(float16_t *rs1, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16mf2x6(_Float16 *rs1, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsseg6e16(rs1, vs3, vl); } -void test_vsseg6e16_v_f16m1x6(float16_t *rs1, vfloat16m1x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16m1x6(_Float16 *rs1, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsseg6e16(rs1, vs3, vl); } @@ -43,15 +43,15 @@ void test_vsseg6e16_v_u16m1x6(uint16_t *rs1, vuint16m1x6_t vs3, size_t vl) { return __riscv_vsseg6e16(rs1, vs3, vl); } -void test_vsseg6e16_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsseg6e16(vm, rs1, vs3, vl); } -void test_vsseg6e16_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsseg6e16(vm, rs1, vs3, vl); } -void test_vsseg6e16_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vfloat16m1x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsseg6e16(vm, rs1, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsseg7e16.c b/auto-generated/gnu-overloaded-tests/vsseg7e16.c index 1efcbb8dd..1dc35c198 100644 --- a/auto-generated/gnu-overloaded-tests/vsseg7e16.c +++ b/auto-generated/gnu-overloaded-tests/vsseg7e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg7e16_v_f16mf4x7(float16_t *rs1, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16mf4x7(_Float16 *rs1, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsseg7e16(rs1, vs3, vl); } -void test_vsseg7e16_v_f16mf2x7(float16_t *rs1, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16mf2x7(_Float16 *rs1, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsseg7e16(rs1, vs3, vl); } -void test_vsseg7e16_v_f16m1x7(float16_t *rs1, vfloat16m1x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16m1x7(_Float16 *rs1, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsseg7e16(rs1, vs3, vl); } @@ -43,15 +43,15 @@ void test_vsseg7e16_v_u16m1x7(uint16_t *rs1, vuint16m1x7_t vs3, size_t vl) { return __riscv_vsseg7e16(rs1, vs3, vl); } -void test_vsseg7e16_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsseg7e16(vm, rs1, vs3, vl); } -void test_vsseg7e16_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsseg7e16(vm, rs1, vs3, vl); } -void test_vsseg7e16_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vfloat16m1x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsseg7e16(vm, rs1, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsseg8e16.c b/auto-generated/gnu-overloaded-tests/vsseg8e16.c index fb4b444dc..0ca5fd679 100644 --- a/auto-generated/gnu-overloaded-tests/vsseg8e16.c +++ b/auto-generated/gnu-overloaded-tests/vsseg8e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg8e16_v_f16mf4x8(float16_t *rs1, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16mf4x8(_Float16 *rs1, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsseg8e16(rs1, vs3, vl); } -void test_vsseg8e16_v_f16mf2x8(float16_t *rs1, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16mf2x8(_Float16 *rs1, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsseg8e16(rs1, vs3, vl); } -void test_vsseg8e16_v_f16m1x8(float16_t *rs1, vfloat16m1x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16m1x8(_Float16 *rs1, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsseg8e16(rs1, vs3, vl); } @@ -43,15 +43,15 @@ void test_vsseg8e16_v_u16m1x8(uint16_t *rs1, vuint16m1x8_t vs3, size_t vl) { return __riscv_vsseg8e16(rs1, vs3, vl); } -void test_vsseg8e16_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsseg8e16(vm, rs1, vs3, vl); } -void test_vsseg8e16_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsseg8e16(vm, rs1, vs3, vl); } -void test_vsseg8e16_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vfloat16m1x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsseg8e16(vm, rs1, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vssseg2e16.c b/auto-generated/gnu-overloaded-tests/vssseg2e16.c index dabf75068..e416df926 100644 --- a/auto-generated/gnu-overloaded-tests/vssseg2e16.c +++ b/auto-generated/gnu-overloaded-tests/vssseg2e16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg2e16_v_f16mf4x2(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16mf4x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vssseg2e16(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16mf2x2(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16mf2x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vssseg2e16(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m1x2(float16_t *rs1, ptrdiff_t rs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m1x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vssseg2e16(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m2x2(float16_t *rs1, ptrdiff_t rs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m2x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vssseg2e16(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m4x2(float16_t *rs1, ptrdiff_t rs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m4x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vssseg2e16(rs1, rs2, vs3, vl); } @@ -67,23 +67,23 @@ void test_vssseg2e16_v_u16m4x2(uint16_t *rs1, ptrdiff_t rs2, vuint16m4x2_t vs3, return __riscv_vssseg2e16(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vssseg2e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vssseg2e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vssseg2e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vssseg2e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vssseg2e16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vssseg3e16.c b/auto-generated/gnu-overloaded-tests/vssseg3e16.c index 44a0a4639..55d032885 100644 --- a/auto-generated/gnu-overloaded-tests/vssseg3e16.c +++ b/auto-generated/gnu-overloaded-tests/vssseg3e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg3e16_v_f16mf4x3(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16mf4x3(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vssseg3e16(rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16mf2x3(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16mf2x3(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vssseg3e16(rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16m1x3(float16_t *rs1, ptrdiff_t rs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16m1x3(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vssseg3e16(rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16m2x3(float16_t *rs1, ptrdiff_t rs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16m2x3(_Float16 *rs1, ptrdiff_t rs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vssseg3e16(rs1, rs2, vs3, vl); } @@ -55,19 +55,19 @@ void test_vssseg3e16_v_u16m2x3(uint16_t *rs1, ptrdiff_t rs2, vuint16m2x3_t vs3, return __riscv_vssseg3e16(rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vssseg3e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vssseg3e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vssseg3e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vssseg3e16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vssseg4e16.c b/auto-generated/gnu-overloaded-tests/vssseg4e16.c index 6d13ff487..2aae3c66b 100644 --- a/auto-generated/gnu-overloaded-tests/vssseg4e16.c +++ b/auto-generated/gnu-overloaded-tests/vssseg4e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg4e16_v_f16mf4x4(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16mf4x4(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vssseg4e16(rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16mf2x4(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16mf2x4(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vssseg4e16(rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16m1x4(float16_t *rs1, ptrdiff_t rs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16m1x4(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vssseg4e16(rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16m2x4(float16_t *rs1, ptrdiff_t rs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16m2x4(_Float16 *rs1, ptrdiff_t rs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vssseg4e16(rs1, rs2, vs3, vl); } @@ -55,19 +55,19 @@ void test_vssseg4e16_v_u16m2x4(uint16_t *rs1, ptrdiff_t rs2, vuint16m2x4_t vs3, return __riscv_vssseg4e16(rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vssseg4e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vssseg4e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vssseg4e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vssseg4e16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vssseg5e16.c b/auto-generated/gnu-overloaded-tests/vssseg5e16.c index ca69770c3..d4f33b98e 100644 --- a/auto-generated/gnu-overloaded-tests/vssseg5e16.c +++ b/auto-generated/gnu-overloaded-tests/vssseg5e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg5e16_v_f16mf4x5(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vssseg5e16_v_f16mf4x5(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vssseg5e16(rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16mf2x5(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vssseg5e16_v_f16mf2x5(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vssseg5e16(rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16m1x5(float16_t *rs1, ptrdiff_t rs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vssseg5e16_v_f16m1x5(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vssseg5e16(rs1, rs2, vs3, vl); } @@ -43,15 +43,15 @@ void test_vssseg5e16_v_u16m1x5(uint16_t *rs1, ptrdiff_t rs2, vuint16m1x5_t vs3, return __riscv_vssseg5e16(rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vssseg5e16_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vssseg5e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vssseg5e16_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vssseg5e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vssseg5e16_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vssseg5e16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vssseg6e16.c b/auto-generated/gnu-overloaded-tests/vssseg6e16.c index 43292f548..6f74587e8 100644 --- a/auto-generated/gnu-overloaded-tests/vssseg6e16.c +++ b/auto-generated/gnu-overloaded-tests/vssseg6e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg6e16_v_f16mf4x6(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vssseg6e16_v_f16mf4x6(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vssseg6e16(rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16mf2x6(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vssseg6e16_v_f16mf2x6(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vssseg6e16(rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16m1x6(float16_t *rs1, ptrdiff_t rs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vssseg6e16_v_f16m1x6(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vssseg6e16(rs1, rs2, vs3, vl); } @@ -43,15 +43,15 @@ void test_vssseg6e16_v_u16m1x6(uint16_t *rs1, ptrdiff_t rs2, vuint16m1x6_t vs3, return __riscv_vssseg6e16(rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vssseg6e16_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vssseg6e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vssseg6e16_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vssseg6e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vssseg6e16_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vssseg6e16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vssseg7e16.c b/auto-generated/gnu-overloaded-tests/vssseg7e16.c index 18c72e518..520aa7b25 100644 --- a/auto-generated/gnu-overloaded-tests/vssseg7e16.c +++ b/auto-generated/gnu-overloaded-tests/vssseg7e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg7e16_v_f16mf4x7(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vssseg7e16_v_f16mf4x7(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vssseg7e16(rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16mf2x7(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vssseg7e16_v_f16mf2x7(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vssseg7e16(rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16m1x7(float16_t *rs1, ptrdiff_t rs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vssseg7e16_v_f16m1x7(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vssseg7e16(rs1, rs2, vs3, vl); } @@ -43,15 +43,15 @@ void test_vssseg7e16_v_u16m1x7(uint16_t *rs1, ptrdiff_t rs2, vuint16m1x7_t vs3, return __riscv_vssseg7e16(rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vssseg7e16_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vssseg7e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vssseg7e16_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vssseg7e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vssseg7e16_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vssseg7e16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vssseg8e16.c b/auto-generated/gnu-overloaded-tests/vssseg8e16.c index 0da687b85..fb71afb1f 100644 --- a/auto-generated/gnu-overloaded-tests/vssseg8e16.c +++ b/auto-generated/gnu-overloaded-tests/vssseg8e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg8e16_v_f16mf4x8(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vssseg8e16_v_f16mf4x8(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vssseg8e16(rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16mf2x8(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vssseg8e16_v_f16mf2x8(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vssseg8e16(rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16m1x8(float16_t *rs1, ptrdiff_t rs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vssseg8e16_v_f16m1x8(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vssseg8e16(rs1, rs2, vs3, vl); } @@ -43,15 +43,15 @@ void test_vssseg8e16_v_u16m1x8(uint16_t *rs1, ptrdiff_t rs2, vuint16m1x8_t vs3, return __riscv_vssseg8e16(rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vssseg8e16_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vssseg8e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vssseg8e16_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vssseg8e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vssseg8e16_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vssseg8e16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxei16.c b/auto-generated/gnu-overloaded-tests/vsuxei16.c index 54713ee63..96088a423 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxei16.c +++ b/auto-generated/gnu-overloaded-tests/vsuxei16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxei16_v_f16mf4(float16_t *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsuxei16_v_f16mf4(_Float16 *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei16(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16mf2(float16_t *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsuxei16_v_f16mf2(_Float16 *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei16(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m1(float16_t *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsuxei16_v_f16m1(_Float16 *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei16(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m2(float16_t *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsuxei16_v_f16m2(_Float16 *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei16(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m4(float16_t *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsuxei16_v_f16m4(_Float16 *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei16(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m8(float16_t *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsuxei16_v_f16m8(_Float16 *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsuxei16(rs1, rs2, vs3, vl); } @@ -235,27 +235,27 @@ void test_vsuxei16_v_u64m8(uint64_t *rs1, vuint16m2_t rs2, vuint64m8_t vs3, size return __riscv_vsuxei16(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsuxei16_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei16(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsuxei16_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei16(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsuxei16_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei16(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsuxei16_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei16(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsuxei16_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei16(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m8_m(vbool2_t vm, float16_t *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsuxei16_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsuxei16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxei32.c b/auto-generated/gnu-overloaded-tests/vsuxei32.c index be2061009..b6114bdd8 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxei32.c +++ b/auto-generated/gnu-overloaded-tests/vsuxei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxei32_v_f16mf4(float16_t *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsuxei32_v_f16mf4(_Float16 *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei32(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16mf2(float16_t *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsuxei32_v_f16mf2(_Float16 *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei32(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m1(float16_t *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsuxei32_v_f16m1(_Float16 *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei32(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m2(float16_t *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsuxei32_v_f16m2(_Float16 *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei32(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m4(float16_t *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsuxei32_v_f16m4(_Float16 *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei32(rs1, rs2, vs3, vl); } @@ -215,23 +215,23 @@ void test_vsuxei32_v_u64m8(uint64_t *rs1, vuint32m4_t rs2, vuint64m8_t vs3, size return __riscv_vsuxei32(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsuxei32_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei32(vm, rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsuxei32_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei32(vm, rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsuxei32_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei32(vm, rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsuxei32_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei32(vm, rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsuxei32_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei32(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxei64.c b/auto-generated/gnu-overloaded-tests/vsuxei64.c index 2e13fc2cb..6d6b8136e 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxei64.c +++ b/auto-generated/gnu-overloaded-tests/vsuxei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxei64_v_f16mf4(float16_t *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsuxei64_v_f16mf4(_Float16 *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei64(rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16mf2(float16_t *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsuxei64_v_f16mf2(_Float16 *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei64(rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16m1(float16_t *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsuxei64_v_f16m1(_Float16 *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei64(rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16m2(float16_t *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsuxei64_v_f16m2(_Float16 *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei64(rs1, rs2, vs3, vl); } @@ -183,19 +183,19 @@ void test_vsuxei64_v_u64m8(uint64_t *rs1, vuint64m8_t rs2, vuint64m8_t vs3, size return __riscv_vsuxei64(rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsuxei64_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei64(vm, rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsuxei64_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei64(vm, rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsuxei64_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei64(vm, rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsuxei64_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei64(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxei8.c b/auto-generated/gnu-overloaded-tests/vsuxei8.c index 7335d4dca..f5c29f4a2 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxei8.c +++ b/auto-generated/gnu-overloaded-tests/vsuxei8.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxei8_v_f16mf4(float16_t *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsuxei8_v_f16mf4(_Float16 *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei8(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16mf2(float16_t *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsuxei8_v_f16mf2(_Float16 *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei8(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m1(float16_t *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsuxei8_v_f16m1(_Float16 *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei8(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m2(float16_t *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsuxei8_v_f16m2(_Float16 *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei8(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m4(float16_t *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsuxei8_v_f16m4(_Float16 *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei8(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m8(float16_t *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsuxei8_v_f16m8(_Float16 *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsuxei8(rs1, rs2, vs3, vl); } @@ -243,27 +243,27 @@ void test_vsuxei8_v_u64m8(uint64_t *rs1, vuint8m1_t rs2, vuint64m8_t vs3, size_t return __riscv_vsuxei8(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { +void test_vsuxei8_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei8(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { +void test_vsuxei8_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei8(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { +void test_vsuxei8_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei8(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { +void test_vsuxei8_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei8(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { +void test_vsuxei8_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei8(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m8_m(vbool2_t vm, float16_t *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { +void test_vsuxei8_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsuxei8(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg2ei16.c b/auto-generated/gnu-overloaded-tests/vsuxseg2ei16.c index 0f8c4a992..48a09ba8d 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg2ei16.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg2ei16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg2ei16_v_f16mf4x2(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16mf4x2(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16mf2x2(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16mf2x2(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m1x2(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16m1x2(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m2x2(float16_t *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16m2x2(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m4x2(float16_t *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16m4x2(_Float16 *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(rs1, vs2, vs3, vl); } @@ -199,23 +199,23 @@ void test_vsuxseg2ei16_v_u64m4x2(uint64_t *rs1, vuint16m1_t vs2, vuint64m4x2_t v return __riscv_vsuxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsuxseg2ei16_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg2ei32.c b/auto-generated/gnu-overloaded-tests/vsuxseg2ei32.c index 9464c72f0..fdaf8a24b 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg2ei32.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg2ei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg2ei32_v_f16mf4x2(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16mf4x2(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16mf2x2(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16mf2x2(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m1x2(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16m1x2(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m2x2(float16_t *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16m2x2(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m4x2(float16_t *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16m4x2(_Float16 *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(rs1, vs2, vs3, vl); } @@ -191,23 +191,23 @@ void test_vsuxseg2ei32_v_u64m4x2(uint64_t *rs1, vuint32m2_t vs2, vuint64m4x2_t v return __riscv_vsuxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsuxseg2ei32_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg2ei64.c b/auto-generated/gnu-overloaded-tests/vsuxseg2ei64.c index e6a4aee9b..6d3922e6d 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg2ei64.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg2ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg2ei64_v_f16mf4x2(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsuxseg2ei64_v_f16mf4x2(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16mf2x2(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsuxseg2ei64_v_f16mf2x2(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16m1x2(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsuxseg2ei64_v_f16m1x2(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16m2x2(float16_t *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsuxseg2ei64_v_f16m2x2(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64(rs1, vs2, vs3, vl); } @@ -171,19 +171,19 @@ void test_vsuxseg2ei64_v_u64m4x2(uint64_t *rs1, vuint64m4_t vs2, vuint64m4x2_t v return __riscv_vsuxseg2ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsuxseg2ei64_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsuxseg2ei64_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsuxseg2ei64_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsuxseg2ei64_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg2ei8.c b/auto-generated/gnu-overloaded-tests/vsuxseg2ei8.c index 446fdeb54..a2d8d1ae1 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg2ei8.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg2ei8.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg2ei8_v_f16mf4x2(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16mf4x2(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16mf2x2(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16mf2x2(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m1x2(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16m1x2(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m2x2(float16_t *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16m2x2(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m4x2(float16_t *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16m4x2(_Float16 *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(rs1, vs2, vs3, vl); } @@ -199,23 +199,23 @@ void test_vsuxseg2ei8_v_u64m4x2(uint64_t *rs1, vuint8mf2_t vs2, vuint64m4x2_t vs return __riscv_vsuxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { +void test_vsuxseg2ei8_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg3ei16.c b/auto-generated/gnu-overloaded-tests/vsuxseg3ei16.c index 1a206666f..bfc3428f4 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg3ei16.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg3ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg3ei16_v_f16mf4x3(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsuxseg3ei16_v_f16mf4x3(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16mf2x3(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsuxseg3ei16_v_f16mf2x3(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16m1x3(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsuxseg3ei16_v_f16m1x3(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16m2x3(float16_t *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsuxseg3ei16_v_f16m2x3(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsuxseg3ei16_v_u64m2x3(uint64_t *rs1, vuint16mf2_t vs2, vuint64m2x3_t return __riscv_vsuxseg3ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsuxseg3ei16_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsuxseg3ei16_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsuxseg3ei16_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsuxseg3ei16_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg3ei32.c b/auto-generated/gnu-overloaded-tests/vsuxseg3ei32.c index 6faa437ab..2e48eb5c0 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg3ei32.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg3ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg3ei32_v_f16mf4x3(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsuxseg3ei32_v_f16mf4x3(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16mf2x3(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsuxseg3ei32_v_f16mf2x3(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16m1x3(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsuxseg3ei32_v_f16m1x3(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16m2x3(float16_t *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsuxseg3ei32_v_f16m2x3(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsuxseg3ei32_v_u64m2x3(uint64_t *rs1, vuint32m1_t vs2, vuint64m2x3_t v return __riscv_vsuxseg3ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsuxseg3ei32_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsuxseg3ei32_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsuxseg3ei32_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsuxseg3ei32_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg3ei64.c b/auto-generated/gnu-overloaded-tests/vsuxseg3ei64.c index 8e0599ca9..13a43984b 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg3ei64.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg3ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg3ei64_v_f16mf4x3(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsuxseg3ei64_v_f16mf4x3(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16mf2x3(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsuxseg3ei64_v_f16mf2x3(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16m1x3(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsuxseg3ei64_v_f16m1x3(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16m2x3(float16_t *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsuxseg3ei64_v_f16m2x3(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64(rs1, vs2, vs3, vl); } @@ -147,19 +147,19 @@ void test_vsuxseg3ei64_v_u64m2x3(uint64_t *rs1, vuint64m2_t vs2, vuint64m2x3_t v return __riscv_vsuxseg3ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsuxseg3ei64_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsuxseg3ei64_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsuxseg3ei64_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsuxseg3ei64_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg3ei8.c b/auto-generated/gnu-overloaded-tests/vsuxseg3ei8.c index 6aea2f08f..45c77e711 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg3ei8.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg3ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg3ei8_v_f16mf4x3(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsuxseg3ei8_v_f16mf4x3(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16mf2x3(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsuxseg3ei8_v_f16mf2x3(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16m1x3(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsuxseg3ei8_v_f16m1x3(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16m2x3(float16_t *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsuxseg3ei8_v_f16m2x3(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsuxseg3ei8_v_u64m2x3(uint64_t *rs1, vuint8mf4_t vs2, vuint64m2x3_t vs return __riscv_vsuxseg3ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsuxseg3ei8_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsuxseg3ei8_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { +void test_vsuxseg3ei8_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { +void test_vsuxseg3ei8_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg4ei16.c b/auto-generated/gnu-overloaded-tests/vsuxseg4ei16.c index 1264a9bb8..8d82e59db 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg4ei16.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg4ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg4ei16_v_f16mf4x4(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsuxseg4ei16_v_f16mf4x4(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16mf2x4(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsuxseg4ei16_v_f16mf2x4(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16m1x4(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsuxseg4ei16_v_f16m1x4(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16m2x4(float16_t *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsuxseg4ei16_v_f16m2x4(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsuxseg4ei16_v_u64m2x4(uint64_t *rs1, vuint16mf2_t vs2, vuint64m2x4_t return __riscv_vsuxseg4ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsuxseg4ei16_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsuxseg4ei16_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsuxseg4ei16_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsuxseg4ei16_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg4ei32.c b/auto-generated/gnu-overloaded-tests/vsuxseg4ei32.c index cbfa5e92c..f306fe750 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg4ei32.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg4ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg4ei32_v_f16mf4x4(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsuxseg4ei32_v_f16mf4x4(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16mf2x4(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsuxseg4ei32_v_f16mf2x4(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16m1x4(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsuxseg4ei32_v_f16m1x4(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16m2x4(float16_t *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsuxseg4ei32_v_f16m2x4(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsuxseg4ei32_v_u64m2x4(uint64_t *rs1, vuint32m1_t vs2, vuint64m2x4_t v return __riscv_vsuxseg4ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsuxseg4ei32_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsuxseg4ei32_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsuxseg4ei32_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsuxseg4ei32_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg4ei64.c b/auto-generated/gnu-overloaded-tests/vsuxseg4ei64.c index 06c8f119d..6587b1d19 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg4ei64.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg4ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg4ei64_v_f16mf4x4(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsuxseg4ei64_v_f16mf4x4(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16mf2x4(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsuxseg4ei64_v_f16mf2x4(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16m1x4(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsuxseg4ei64_v_f16m1x4(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16m2x4(float16_t *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsuxseg4ei64_v_f16m2x4(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64(rs1, vs2, vs3, vl); } @@ -147,19 +147,19 @@ void test_vsuxseg4ei64_v_u64m2x4(uint64_t *rs1, vuint64m2_t vs2, vuint64m2x4_t v return __riscv_vsuxseg4ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsuxseg4ei64_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsuxseg4ei64_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsuxseg4ei64_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsuxseg4ei64_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg4ei8.c b/auto-generated/gnu-overloaded-tests/vsuxseg4ei8.c index e72d16ba9..94a6d0477 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg4ei8.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg4ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg4ei8_v_f16mf4x4(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsuxseg4ei8_v_f16mf4x4(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16mf2x4(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsuxseg4ei8_v_f16mf2x4(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16m1x4(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsuxseg4ei8_v_f16m1x4(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16m2x4(float16_t *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsuxseg4ei8_v_f16m2x4(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8(rs1, vs2, vs3, vl); } @@ -155,19 +155,19 @@ void test_vsuxseg4ei8_v_u64m2x4(uint64_t *rs1, vuint8mf4_t vs2, vuint64m2x4_t vs return __riscv_vsuxseg4ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsuxseg4ei8_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsuxseg4ei8_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { +void test_vsuxseg4ei8_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { +void test_vsuxseg4ei8_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg5ei16.c b/auto-generated/gnu-overloaded-tests/vsuxseg5ei16.c index 3796fd198..d9251a09f 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg5ei16.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg5ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg5ei16_v_f16mf4x5(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsuxseg5ei16_v_f16mf4x5(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16mf2x5(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsuxseg5ei16_v_f16mf2x5(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16m1x5(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsuxseg5ei16_v_f16m1x5(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg5ei16_v_u64m1x5(uint64_t *rs1, vuint16mf4_t vs2, vuint64m1x5_t return __riscv_vsuxseg5ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsuxseg5ei16_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsuxseg5ei16_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsuxseg5ei16_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg5ei32.c b/auto-generated/gnu-overloaded-tests/vsuxseg5ei32.c index f87f9fd1f..92032f27f 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg5ei32.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg5ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg5ei32_v_f16mf4x5(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsuxseg5ei32_v_f16mf4x5(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16mf2x5(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsuxseg5ei32_v_f16mf2x5(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16m1x5(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsuxseg5ei32_v_f16m1x5(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg5ei32_v_u64m1x5(uint64_t *rs1, vuint32mf2_t vs2, vuint64m1x5_t return __riscv_vsuxseg5ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsuxseg5ei32_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsuxseg5ei32_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsuxseg5ei32_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg5ei64.c b/auto-generated/gnu-overloaded-tests/vsuxseg5ei64.c index 9e1959ff8..06676bc9c 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg5ei64.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg5ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg5ei64_v_f16mf4x5(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsuxseg5ei64_v_f16mf4x5(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16mf2x5(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsuxseg5ei64_v_f16mf2x5(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16m1x5(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsuxseg5ei64_v_f16m1x5(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg5ei64_v_u64m1x5(uint64_t *rs1, vuint64m1_t vs2, vuint64m1x5_t v return __riscv_vsuxseg5ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsuxseg5ei64_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsuxseg5ei64_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsuxseg5ei64_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg5ei8.c b/auto-generated/gnu-overloaded-tests/vsuxseg5ei8.c index fa0e4727b..409d92c1f 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg5ei8.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg5ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg5ei8_v_f16mf4x5(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsuxseg5ei8_v_f16mf4x5(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16mf2x5(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsuxseg5ei8_v_f16mf2x5(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16m1x5(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsuxseg5ei8_v_f16m1x5(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg5ei8_v_u64m1x5(uint64_t *rs1, vuint8mf8_t vs2, vuint64m1x5_t vs return __riscv_vsuxseg5ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsuxseg5ei8_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsuxseg5ei8_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { +void test_vsuxseg5ei8_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg6ei16.c b/auto-generated/gnu-overloaded-tests/vsuxseg6ei16.c index e4178969d..e8f6ea157 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg6ei16.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg6ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg6ei16_v_f16mf4x6(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsuxseg6ei16_v_f16mf4x6(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16mf2x6(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsuxseg6ei16_v_f16mf2x6(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16m1x6(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsuxseg6ei16_v_f16m1x6(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg6ei16_v_u64m1x6(uint64_t *rs1, vuint16mf4_t vs2, vuint64m1x6_t return __riscv_vsuxseg6ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsuxseg6ei16_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsuxseg6ei16_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsuxseg6ei16_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg6ei32.c b/auto-generated/gnu-overloaded-tests/vsuxseg6ei32.c index 9ad34f81a..1d21529a3 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg6ei32.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg6ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg6ei32_v_f16mf4x6(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsuxseg6ei32_v_f16mf4x6(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16mf2x6(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsuxseg6ei32_v_f16mf2x6(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16m1x6(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsuxseg6ei32_v_f16m1x6(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg6ei32_v_u64m1x6(uint64_t *rs1, vuint32mf2_t vs2, vuint64m1x6_t return __riscv_vsuxseg6ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsuxseg6ei32_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsuxseg6ei32_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsuxseg6ei32_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg6ei64.c b/auto-generated/gnu-overloaded-tests/vsuxseg6ei64.c index ab1719d9f..12759b984 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg6ei64.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg6ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg6ei64_v_f16mf4x6(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsuxseg6ei64_v_f16mf4x6(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16mf2x6(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsuxseg6ei64_v_f16mf2x6(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16m1x6(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsuxseg6ei64_v_f16m1x6(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg6ei64_v_u64m1x6(uint64_t *rs1, vuint64m1_t vs2, vuint64m1x6_t v return __riscv_vsuxseg6ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsuxseg6ei64_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsuxseg6ei64_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsuxseg6ei64_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg6ei8.c b/auto-generated/gnu-overloaded-tests/vsuxseg6ei8.c index fb82b41a3..afbeffc43 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg6ei8.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg6ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg6ei8_v_f16mf4x6(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsuxseg6ei8_v_f16mf4x6(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16mf2x6(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsuxseg6ei8_v_f16mf2x6(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16m1x6(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsuxseg6ei8_v_f16m1x6(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg6ei8_v_u64m1x6(uint64_t *rs1, vuint8mf8_t vs2, vuint64m1x6_t vs return __riscv_vsuxseg6ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsuxseg6ei8_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsuxseg6ei8_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { +void test_vsuxseg6ei8_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg7ei16.c b/auto-generated/gnu-overloaded-tests/vsuxseg7ei16.c index 12feb1cff..2d59b20de 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg7ei16.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg7ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg7ei16_v_f16mf4x7(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsuxseg7ei16_v_f16mf4x7(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16mf2x7(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsuxseg7ei16_v_f16mf2x7(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16m1x7(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsuxseg7ei16_v_f16m1x7(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg7ei16_v_u64m1x7(uint64_t *rs1, vuint16mf4_t vs2, vuint64m1x7_t return __riscv_vsuxseg7ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsuxseg7ei16_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsuxseg7ei16_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsuxseg7ei16_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg7ei32.c b/auto-generated/gnu-overloaded-tests/vsuxseg7ei32.c index 70c816a38..493958595 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg7ei32.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg7ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg7ei32_v_f16mf4x7(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsuxseg7ei32_v_f16mf4x7(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16mf2x7(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsuxseg7ei32_v_f16mf2x7(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16m1x7(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsuxseg7ei32_v_f16m1x7(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg7ei32_v_u64m1x7(uint64_t *rs1, vuint32mf2_t vs2, vuint64m1x7_t return __riscv_vsuxseg7ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsuxseg7ei32_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsuxseg7ei32_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsuxseg7ei32_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg7ei64.c b/auto-generated/gnu-overloaded-tests/vsuxseg7ei64.c index 3e2bd8476..100c9a93d 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg7ei64.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg7ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg7ei64_v_f16mf4x7(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsuxseg7ei64_v_f16mf4x7(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16mf2x7(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsuxseg7ei64_v_f16mf2x7(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16m1x7(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsuxseg7ei64_v_f16m1x7(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg7ei64_v_u64m1x7(uint64_t *rs1, vuint64m1_t vs2, vuint64m1x7_t v return __riscv_vsuxseg7ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsuxseg7ei64_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsuxseg7ei64_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsuxseg7ei64_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg7ei8.c b/auto-generated/gnu-overloaded-tests/vsuxseg7ei8.c index 23842c535..613f021e0 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg7ei8.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg7ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg7ei8_v_f16mf4x7(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsuxseg7ei8_v_f16mf4x7(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16mf2x7(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsuxseg7ei8_v_f16mf2x7(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16m1x7(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsuxseg7ei8_v_f16m1x7(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg7ei8_v_u64m1x7(uint64_t *rs1, vuint8mf8_t vs2, vuint64m1x7_t vs return __riscv_vsuxseg7ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsuxseg7ei8_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsuxseg7ei8_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { +void test_vsuxseg7ei8_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg8ei16.c b/auto-generated/gnu-overloaded-tests/vsuxseg8ei16.c index b2509d565..2236bd3f0 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg8ei16.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg8ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg8ei16_v_f16mf4x8(float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsuxseg8ei16_v_f16mf4x8(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16mf2x8(float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsuxseg8ei16_v_f16mf2x8(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16m1x8(float16_t *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsuxseg8ei16_v_f16m1x8(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg8ei16_v_u64m1x8(uint64_t *rs1, vuint16mf4_t vs2, vuint64m1x8_t return __riscv_vsuxseg8ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsuxseg8ei16_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsuxseg8ei16_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsuxseg8ei16_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg8ei32.c b/auto-generated/gnu-overloaded-tests/vsuxseg8ei32.c index 7da627fe6..0d400cb2c 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg8ei32.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg8ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg8ei32_v_f16mf4x8(float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsuxseg8ei32_v_f16mf4x8(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16mf2x8(float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsuxseg8ei32_v_f16mf2x8(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16m1x8(float16_t *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsuxseg8ei32_v_f16m1x8(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg8ei32_v_u64m1x8(uint64_t *rs1, vuint32mf2_t vs2, vuint64m1x8_t return __riscv_vsuxseg8ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsuxseg8ei32_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsuxseg8ei32_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsuxseg8ei32_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg8ei64.c b/auto-generated/gnu-overloaded-tests/vsuxseg8ei64.c index 8a8eeecbc..2cce9db59 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg8ei64.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg8ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg8ei64_v_f16mf4x8(float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsuxseg8ei64_v_f16mf4x8(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16mf2x8(float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsuxseg8ei64_v_f16mf2x8(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16m1x8(float16_t *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsuxseg8ei64_v_f16m1x8(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg8ei64_v_u64m1x8(uint64_t *rs1, vuint64m1_t vs2, vuint64m1x8_t v return __riscv_vsuxseg8ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsuxseg8ei64_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsuxseg8ei64_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsuxseg8ei64_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/gnu-overloaded-tests/vsuxseg8ei8.c b/auto-generated/gnu-overloaded-tests/vsuxseg8ei8.c index ba580cde0..02dd9ed90 100644 --- a/auto-generated/gnu-overloaded-tests/vsuxseg8ei8.c +++ b/auto-generated/gnu-overloaded-tests/vsuxseg8ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg8ei8_v_f16mf4x8(float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsuxseg8ei8_v_f16mf4x8(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16mf2x8(float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsuxseg8ei8_v_f16mf2x8(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16m1x8(float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsuxseg8ei8_v_f16m1x8(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8(rs1, vs2, vs3, vl); } @@ -111,15 +111,15 @@ void test_vsuxseg8ei8_v_u64m1x8(uint64_t *rs1, vuint8mf8_t vs2, vuint64m1x8_t vs return __riscv_vsuxseg8ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsuxseg8ei8_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsuxseg8ei8_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { +void test_vsuxseg8ei8_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vle16.c b/auto-generated/overloaded-api-testing/vle16.c index 54462af13..c4712fe8b 100644 --- a/auto-generated/overloaded-api-testing/vle16.c +++ b/auto-generated/overloaded-api-testing/vle16.c @@ -5,33 +5,30 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vle16_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vle16_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16(vm, rs1, vl); } -vfloat16mf2_t test_vle16_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vle16_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16(vm, rs1, vl); } -vfloat16m1_t test_vle16_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vle16_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16(vm, rs1, vl); } -vfloat16m2_t test_vle16_v_f16m2_m(vbool8_t vm, const float16_t *rs1, - size_t vl) { +vfloat16m2_t test_vle16_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16(vm, rs1, vl); } -vfloat16m4_t test_vle16_v_f16m4_m(vbool4_t vm, const float16_t *rs1, - size_t vl) { +vfloat16m4_t test_vle16_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16(vm, rs1, vl); } -vfloat16m8_t test_vle16_v_f16m8_m(vbool2_t vm, const float16_t *rs1, - size_t vl) { +vfloat16m8_t test_vle16_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vle16(vm, rs1, vl); } diff --git a/auto-generated/overloaded-api-testing/vle16ff.c b/auto-generated/overloaded-api-testing/vle16ff.c index 77eac2388..2defbdb66 100644 --- a/auto-generated/overloaded-api-testing/vle16ff.c +++ b/auto-generated/overloaded-api-testing/vle16ff.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vle16ff_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vle16ff_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff(vm, rs1, new_vl, vl); } -vfloat16mf2_t test_vle16ff_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vle16ff_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff(vm, rs1, new_vl, vl); } -vfloat16m1_t test_vle16ff_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vle16ff_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff(vm, rs1, new_vl, vl); } -vfloat16m2_t test_vle16ff_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vle16ff_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff(vm, rs1, new_vl, vl); } -vfloat16m4_t test_vle16ff_v_f16m4_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4_t test_vle16ff_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff(vm, rs1, new_vl, vl); } -vfloat16m8_t test_vle16ff_v_f16m8_m(vbool2_t vm, const float16_t *rs1, +vfloat16m8_t test_vle16ff_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff(vm, rs1, new_vl, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxei16.c b/auto-generated/overloaded-api-testing/vloxei16.c index be89a03aa..34b3e992c 100644 --- a/auto-generated/overloaded-api-testing/vloxei16.c +++ b/auto-generated/overloaded-api-testing/vloxei16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei16_v_f16mf4(const float16_t *rs1, vuint16mf4_t rs2, +vfloat16mf4_t test_vloxei16_v_f16mf4(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16(rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2(const float16_t *rs1, vuint16mf2_t rs2, +vfloat16mf2_t test_vloxei16_v_f16mf2(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16(rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1(const float16_t *rs1, vuint16m1_t rs2, +vfloat16m1_t test_vloxei16_v_f16m1(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16(rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2(const float16_t *rs1, vuint16m2_t rs2, +vfloat16m2_t test_vloxei16_v_f16m2(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16(rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4(const float16_t *rs1, vuint16m4_t rs2, +vfloat16m4_t test_vloxei16_v_f16m4(const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16(rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8(const float16_t *rs1, vuint16m8_t rs2, +vfloat16m8_t test_vloxei16_v_f16m8(const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16(rs1, rs2, vl); } @@ -287,32 +287,32 @@ vuint64m8_t test_vloxei16_v_u64m8(const uint64_t *rs1, vuint16m2_t rs2, return __riscv_vloxei16(rs1, rs2, vl); } -vfloat16mf4_t test_vloxei16_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vloxei16_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vloxei16_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16(vm, rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vloxei16_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16(vm, rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vloxei16_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16(vm, rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4_t test_vloxei16_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16(vm, rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8_m(vbool2_t vm, const float16_t *rs1, +vfloat16m8_t test_vloxei16_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxei32.c b/auto-generated/overloaded-api-testing/vloxei32.c index da7ad9671..f311f2978 100644 --- a/auto-generated/overloaded-api-testing/vloxei32.c +++ b/auto-generated/overloaded-api-testing/vloxei32.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei32_v_f16mf4(const float16_t *rs1, vuint32mf2_t rs2, +vfloat16mf4_t test_vloxei32_v_f16mf4(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32(rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2(const float16_t *rs1, vuint32m1_t rs2, +vfloat16mf2_t test_vloxei32_v_f16mf2(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32(rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1(const float16_t *rs1, vuint32m2_t rs2, +vfloat16m1_t test_vloxei32_v_f16m1(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32(rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2(const float16_t *rs1, vuint32m4_t rs2, +vfloat16m2_t test_vloxei32_v_f16m2(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32(rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4(const float16_t *rs1, vuint32m8_t rs2, +vfloat16m4_t test_vloxei32_v_f16m4(const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32(rs1, rs2, vl); } @@ -263,27 +263,27 @@ vuint64m8_t test_vloxei32_v_u64m8(const uint64_t *rs1, vuint32m4_t rs2, return __riscv_vloxei32(rs1, rs2, vl); } -vfloat16mf4_t test_vloxei32_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vloxei32_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vloxei32_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32(vm, rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vloxei32_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32(vm, rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vloxei32_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32(vm, rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4_t test_vloxei32_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxei64.c b/auto-generated/overloaded-api-testing/vloxei64.c index 713959a91..b0fd12574 100644 --- a/auto-generated/overloaded-api-testing/vloxei64.c +++ b/auto-generated/overloaded-api-testing/vloxei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei64_v_f16mf4(const float16_t *rs1, vuint64m1_t rs2, +vfloat16mf4_t test_vloxei64_v_f16mf4(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64(rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2(const float16_t *rs1, vuint64m2_t rs2, +vfloat16mf2_t test_vloxei64_v_f16mf2(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64(rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1(const float16_t *rs1, vuint64m4_t rs2, +vfloat16m1_t test_vloxei64_v_f16m1(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64(rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2(const float16_t *rs1, vuint64m8_t rs2, +vfloat16m2_t test_vloxei64_v_f16m2(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64(rs1, rs2, vl); } @@ -224,22 +224,22 @@ vuint64m8_t test_vloxei64_v_u64m8(const uint64_t *rs1, vuint64m8_t rs2, return __riscv_vloxei64(rs1, rs2, vl); } -vfloat16mf4_t test_vloxei64_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vloxei64_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vloxei64_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64(vm, rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vloxei64_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64(vm, rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vloxei64_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxei8.c b/auto-generated/overloaded-api-testing/vloxei8.c index cfc37aa00..a0bcaafec 100644 --- a/auto-generated/overloaded-api-testing/vloxei8.c +++ b/auto-generated/overloaded-api-testing/vloxei8.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei8_v_f16mf4(const float16_t *rs1, vuint8mf8_t rs2, +vfloat16mf4_t test_vloxei8_v_f16mf4(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8(rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2(const float16_t *rs1, vuint8mf4_t rs2, +vfloat16mf2_t test_vloxei8_v_f16mf2(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8(rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1_t test_vloxei8_v_f16m1(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8(rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2(const float16_t *rs1, vuint8m1_t rs2, +vfloat16m2_t test_vloxei8_v_f16m2(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8(rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4(const float16_t *rs1, vuint8m2_t rs2, +vfloat16m4_t test_vloxei8_v_f16m4(const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8(rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8(const float16_t *rs1, vuint8m4_t rs2, +vfloat16m8_t test_vloxei8_v_f16m8(const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8(rs1, rs2, vl); } @@ -283,32 +283,32 @@ vuint64m8_t test_vloxei8_v_u64m8(const uint64_t *rs1, vuint8m1_t rs2, return __riscv_vloxei8(rs1, rs2, vl); } -vfloat16mf4_t test_vloxei8_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vloxei8_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vloxei8_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8(vm, rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vloxei8_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8(vm, rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vloxei8_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8(vm, rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4_t test_vloxei8_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8(vm, rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8_m(vbool2_t vm, const float16_t *rs1, +vfloat16m8_t test_vloxei8_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg2ei16.c b/auto-generated/overloaded-api-testing/vloxseg2ei16.c index 911fa86c7..21a1ab38c 100644 --- a/auto-generated/overloaded-api-testing/vloxseg2ei16.c +++ b/auto-generated/overloaded-api-testing/vloxseg2ei16.c @@ -5,28 +5,28 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2(const float16_t *rs1, +vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16(rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2(const float16_t *rs1, +vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16(rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vloxseg2ei16(rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2(const float16_t *rs1, - vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2(const _Float16 *rs1, vuint16m2_t rs2, + size_t vl) { return __riscv_vloxseg2ei16(rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2(const float16_t *rs1, - vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2(const _Float16 *rs1, vuint16m4_t rs2, + size_t vl) { return __riscv_vloxseg2ei16(rs1, rs2, vl); } @@ -246,28 +246,28 @@ vuint64m4x2_t test_vloxseg2ei16_v_u64m4x2(const uint64_t *rs1, vuint16m1_t rs2, } vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16(vm, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg2ei32.c b/auto-generated/overloaded-api-testing/vloxseg2ei32.c index 683edf84c..b2d9495be 100644 --- a/auto-generated/overloaded-api-testing/vloxseg2ei32.c +++ b/auto-generated/overloaded-api-testing/vloxseg2ei32.c @@ -5,28 +5,28 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2(const float16_t *rs1, +vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32(rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2(const float16_t *rs1, +vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32(rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vloxseg2ei32(rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2(const float16_t *rs1, - vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2(const _Float16 *rs1, vuint32m4_t rs2, + size_t vl) { return __riscv_vloxseg2ei32(rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2(const float16_t *rs1, - vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2(const _Float16 *rs1, vuint32m8_t rs2, + size_t vl) { return __riscv_vloxseg2ei32(rs1, rs2, vl); } @@ -236,28 +236,28 @@ vuint64m4x2_t test_vloxseg2ei32_v_u64m4x2(const uint64_t *rs1, vuint32m2_t rs2, } vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32(vm, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg2ei64.c b/auto-generated/overloaded-api-testing/vloxseg2ei64.c index 3b6c2950f..2c48a0159 100644 --- a/auto-generated/overloaded-api-testing/vloxseg2ei64.c +++ b/auto-generated/overloaded-api-testing/vloxseg2ei64.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2(const float16_t *rs1, +vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64(rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2(const float16_t *rs1, +vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64(rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vloxseg2ei64(rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2(const float16_t *rs1, - vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2(const _Float16 *rs1, vuint64m8_t rs2, + size_t vl) { return __riscv_vloxseg2ei64(rs1, rs2, vl); } @@ -211,23 +211,23 @@ vuint64m4x2_t test_vloxseg2ei64_v_u64m4x2(const uint64_t *rs1, vuint64m4_t rs2, } vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64(vm, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg2ei8.c b/auto-generated/overloaded-api-testing/vloxseg2ei8.c index 4b205574c..60ebb5491 100644 --- a/auto-generated/overloaded-api-testing/vloxseg2ei8.c +++ b/auto-generated/overloaded-api-testing/vloxseg2ei8.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2(const float16_t *rs1, +vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8(rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2(const float16_t *rs1, +vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8(rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8(rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2(const float16_t *rs1, vuint8m1_t rs2, +vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8(rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2(const float16_t *rs1, vuint8m2_t rs2, +vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2(const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8(rs1, rs2, vl); } @@ -245,29 +245,27 @@ vuint64m4x2_t test_vloxseg2ei8_v_u64m4x2(const uint64_t *rs1, vuint8mf2_t rs2, return __riscv_vloxseg2ei8(rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg3ei16.c b/auto-generated/overloaded-api-testing/vloxseg3ei16.c index 027e5a771..f5f84c7a5 100644 --- a/auto-generated/overloaded-api-testing/vloxseg3ei16.c +++ b/auto-generated/overloaded-api-testing/vloxseg3ei16.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3(const float16_t *rs1, +vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16(rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3(const float16_t *rs1, +vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16(rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vloxseg3ei16(rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3(const float16_t *rs1, - vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3(const _Float16 *rs1, vuint16m2_t rs2, + size_t vl) { return __riscv_vloxseg3ei16(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m2x3_t test_vloxseg3ei16_v_u64m2x3(const uint64_t *rs1, vuint16mf2_t rs2, } vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16(vm, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg3ei32.c b/auto-generated/overloaded-api-testing/vloxseg3ei32.c index b2e81f228..fc6a74441 100644 --- a/auto-generated/overloaded-api-testing/vloxseg3ei32.c +++ b/auto-generated/overloaded-api-testing/vloxseg3ei32.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3(const float16_t *rs1, +vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32(rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3(const float16_t *rs1, +vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32(rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vloxseg3ei32(rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3(const float16_t *rs1, - vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3(const _Float16 *rs1, vuint32m4_t rs2, + size_t vl) { return __riscv_vloxseg3ei32(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m2x3_t test_vloxseg3ei32_v_u64m2x3(const uint64_t *rs1, vuint32m1_t rs2, } vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32(vm, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg3ei64.c b/auto-generated/overloaded-api-testing/vloxseg3ei64.c index b2e61fdb5..e4f1432e7 100644 --- a/auto-generated/overloaded-api-testing/vloxseg3ei64.c +++ b/auto-generated/overloaded-api-testing/vloxseg3ei64.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3(const float16_t *rs1, +vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64(rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3(const float16_t *rs1, +vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64(rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vloxseg3ei64(rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3(const float16_t *rs1, - vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3(const _Float16 *rs1, vuint64m8_t rs2, + size_t vl) { return __riscv_vloxseg3ei64(rs1, rs2, vl); } @@ -181,23 +181,23 @@ vuint64m2x3_t test_vloxseg3ei64_v_u64m2x3(const uint64_t *rs1, vuint64m2_t rs2, } vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64(vm, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg3ei8.c b/auto-generated/overloaded-api-testing/vloxseg3ei8.c index 704f9f135..fc8c7d5c6 100644 --- a/auto-generated/overloaded-api-testing/vloxseg3ei8.c +++ b/auto-generated/overloaded-api-testing/vloxseg3ei8.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3(const float16_t *rs1, +vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8(rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3(const float16_t *rs1, +vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8(rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8(rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3(const float16_t *rs1, vuint8m1_t rs2, +vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8(rs1, rs2, vl); } @@ -190,24 +190,22 @@ vuint64m2x3_t test_vloxseg3ei8_v_u64m2x3(const uint64_t *rs1, vuint8mf4_t rs2, return __riscv_vloxseg3ei8(rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg4ei16.c b/auto-generated/overloaded-api-testing/vloxseg4ei16.c index 0ebd79709..ad674239a 100644 --- a/auto-generated/overloaded-api-testing/vloxseg4ei16.c +++ b/auto-generated/overloaded-api-testing/vloxseg4ei16.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4(const float16_t *rs1, +vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16(rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4(const float16_t *rs1, +vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16(rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vloxseg4ei16(rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4(const float16_t *rs1, - vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4(const _Float16 *rs1, vuint16m2_t rs2, + size_t vl) { return __riscv_vloxseg4ei16(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m2x4_t test_vloxseg4ei16_v_u64m2x4(const uint64_t *rs1, vuint16mf2_t rs2, } vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16(vm, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg4ei32.c b/auto-generated/overloaded-api-testing/vloxseg4ei32.c index 78862cc6c..0dac0bf86 100644 --- a/auto-generated/overloaded-api-testing/vloxseg4ei32.c +++ b/auto-generated/overloaded-api-testing/vloxseg4ei32.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4(const float16_t *rs1, +vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32(rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4(const float16_t *rs1, +vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32(rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vloxseg4ei32(rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4(const float16_t *rs1, - vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4(const _Float16 *rs1, vuint32m4_t rs2, + size_t vl) { return __riscv_vloxseg4ei32(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m2x4_t test_vloxseg4ei32_v_u64m2x4(const uint64_t *rs1, vuint32m1_t rs2, } vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32(vm, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg4ei64.c b/auto-generated/overloaded-api-testing/vloxseg4ei64.c index 3f2fe1ecd..781f382da 100644 --- a/auto-generated/overloaded-api-testing/vloxseg4ei64.c +++ b/auto-generated/overloaded-api-testing/vloxseg4ei64.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4(const float16_t *rs1, +vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64(rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4(const float16_t *rs1, +vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64(rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vloxseg4ei64(rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4(const float16_t *rs1, - vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4(const _Float16 *rs1, vuint64m8_t rs2, + size_t vl) { return __riscv_vloxseg4ei64(rs1, rs2, vl); } @@ -181,23 +181,23 @@ vuint64m2x4_t test_vloxseg4ei64_v_u64m2x4(const uint64_t *rs1, vuint64m2_t rs2, } vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64(vm, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg4ei8.c b/auto-generated/overloaded-api-testing/vloxseg4ei8.c index c6443ab43..b1233370a 100644 --- a/auto-generated/overloaded-api-testing/vloxseg4ei8.c +++ b/auto-generated/overloaded-api-testing/vloxseg4ei8.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4(const float16_t *rs1, +vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8(rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4(const float16_t *rs1, +vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8(rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8(rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4(const float16_t *rs1, vuint8m1_t rs2, +vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8(rs1, rs2, vl); } @@ -190,24 +190,22 @@ vuint64m2x4_t test_vloxseg4ei8_v_u64m2x4(const uint64_t *rs1, vuint8mf4_t rs2, return __riscv_vloxseg4ei8(rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg5ei16.c b/auto-generated/overloaded-api-testing/vloxseg5ei16.c index b1e597b9e..d5716f28b 100644 --- a/auto-generated/overloaded-api-testing/vloxseg5ei16.c +++ b/auto-generated/overloaded-api-testing/vloxseg5ei16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5(const float16_t *rs1, +vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16(rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5(const float16_t *rs1, +vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16(rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vloxseg5ei16(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x5_t test_vloxseg5ei16_v_u64m1x5(const uint64_t *rs1, vuint16mf4_t rs2, } vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16(vm, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg5ei32.c b/auto-generated/overloaded-api-testing/vloxseg5ei32.c index 452db8921..c31e85820 100644 --- a/auto-generated/overloaded-api-testing/vloxseg5ei32.c +++ b/auto-generated/overloaded-api-testing/vloxseg5ei32.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5(const float16_t *rs1, +vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32(rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5(const float16_t *rs1, +vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32(rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vloxseg5ei32(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x5_t test_vloxseg5ei32_v_u64m1x5(const uint64_t *rs1, vuint32mf2_t rs2, } vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32(vm, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg5ei64.c b/auto-generated/overloaded-api-testing/vloxseg5ei64.c index 6d47043e8..6c140ed8e 100644 --- a/auto-generated/overloaded-api-testing/vloxseg5ei64.c +++ b/auto-generated/overloaded-api-testing/vloxseg5ei64.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5(const float16_t *rs1, +vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64(rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5(const float16_t *rs1, +vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64(rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vloxseg5ei64(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x5_t test_vloxseg5ei64_v_u64m1x5(const uint64_t *rs1, vuint64m1_t rs2, } vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64(vm, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg5ei8.c b/auto-generated/overloaded-api-testing/vloxseg5ei8.c index 39cb2d969..3e28c79f9 100644 --- a/auto-generated/overloaded-api-testing/vloxseg5ei8.c +++ b/auto-generated/overloaded-api-testing/vloxseg5ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5(const float16_t *rs1, +vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8(rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5(const float16_t *rs1, +vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8(rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8(rs1, rs2, vl); } @@ -135,19 +135,17 @@ vuint64m1x5_t test_vloxseg5ei8_v_u64m1x5(const uint64_t *rs1, vuint8mf8_t rs2, return __riscv_vloxseg5ei8(rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg6ei16.c b/auto-generated/overloaded-api-testing/vloxseg6ei16.c index cc2399103..652436f10 100644 --- a/auto-generated/overloaded-api-testing/vloxseg6ei16.c +++ b/auto-generated/overloaded-api-testing/vloxseg6ei16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6(const float16_t *rs1, +vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16(rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6(const float16_t *rs1, +vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16(rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vloxseg6ei16(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x6_t test_vloxseg6ei16_v_u64m1x6(const uint64_t *rs1, vuint16mf4_t rs2, } vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16(vm, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg6ei32.c b/auto-generated/overloaded-api-testing/vloxseg6ei32.c index c68fe3a6a..1eb2580d9 100644 --- a/auto-generated/overloaded-api-testing/vloxseg6ei32.c +++ b/auto-generated/overloaded-api-testing/vloxseg6ei32.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6(const float16_t *rs1, +vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32(rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6(const float16_t *rs1, +vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32(rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vloxseg6ei32(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x6_t test_vloxseg6ei32_v_u64m1x6(const uint64_t *rs1, vuint32mf2_t rs2, } vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32(vm, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg6ei64.c b/auto-generated/overloaded-api-testing/vloxseg6ei64.c index b470bae9c..f99745aaa 100644 --- a/auto-generated/overloaded-api-testing/vloxseg6ei64.c +++ b/auto-generated/overloaded-api-testing/vloxseg6ei64.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6(const float16_t *rs1, +vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64(rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6(const float16_t *rs1, +vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64(rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vloxseg6ei64(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x6_t test_vloxseg6ei64_v_u64m1x6(const uint64_t *rs1, vuint64m1_t rs2, } vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64(vm, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg6ei8.c b/auto-generated/overloaded-api-testing/vloxseg6ei8.c index a6cef9735..2a11c35a1 100644 --- a/auto-generated/overloaded-api-testing/vloxseg6ei8.c +++ b/auto-generated/overloaded-api-testing/vloxseg6ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6(const float16_t *rs1, +vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8(rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6(const float16_t *rs1, +vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8(rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8(rs1, rs2, vl); } @@ -135,19 +135,17 @@ vuint64m1x6_t test_vloxseg6ei8_v_u64m1x6(const uint64_t *rs1, vuint8mf8_t rs2, return __riscv_vloxseg6ei8(rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg7ei16.c b/auto-generated/overloaded-api-testing/vloxseg7ei16.c index c35f6bc8d..b60474dd2 100644 --- a/auto-generated/overloaded-api-testing/vloxseg7ei16.c +++ b/auto-generated/overloaded-api-testing/vloxseg7ei16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7(const float16_t *rs1, +vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16(rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7(const float16_t *rs1, +vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16(rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vloxseg7ei16(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x7_t test_vloxseg7ei16_v_u64m1x7(const uint64_t *rs1, vuint16mf4_t rs2, } vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16(vm, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg7ei32.c b/auto-generated/overloaded-api-testing/vloxseg7ei32.c index 2afa37e6a..4f70ce6e0 100644 --- a/auto-generated/overloaded-api-testing/vloxseg7ei32.c +++ b/auto-generated/overloaded-api-testing/vloxseg7ei32.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7(const float16_t *rs1, +vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32(rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7(const float16_t *rs1, +vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32(rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vloxseg7ei32(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x7_t test_vloxseg7ei32_v_u64m1x7(const uint64_t *rs1, vuint32mf2_t rs2, } vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32(vm, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg7ei64.c b/auto-generated/overloaded-api-testing/vloxseg7ei64.c index bf110c066..cbc2e83b0 100644 --- a/auto-generated/overloaded-api-testing/vloxseg7ei64.c +++ b/auto-generated/overloaded-api-testing/vloxseg7ei64.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7(const float16_t *rs1, +vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64(rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7(const float16_t *rs1, +vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64(rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vloxseg7ei64(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x7_t test_vloxseg7ei64_v_u64m1x7(const uint64_t *rs1, vuint64m1_t rs2, } vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64(vm, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg7ei8.c b/auto-generated/overloaded-api-testing/vloxseg7ei8.c index ec19736d2..ec7cbddfe 100644 --- a/auto-generated/overloaded-api-testing/vloxseg7ei8.c +++ b/auto-generated/overloaded-api-testing/vloxseg7ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7(const float16_t *rs1, +vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8(rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7(const float16_t *rs1, +vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8(rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8(rs1, rs2, vl); } @@ -135,19 +135,17 @@ vuint64m1x7_t test_vloxseg7ei8_v_u64m1x7(const uint64_t *rs1, vuint8mf8_t rs2, return __riscv_vloxseg7ei8(rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg8ei16.c b/auto-generated/overloaded-api-testing/vloxseg8ei16.c index 09494af14..aa7fa1362 100644 --- a/auto-generated/overloaded-api-testing/vloxseg8ei16.c +++ b/auto-generated/overloaded-api-testing/vloxseg8ei16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8(const float16_t *rs1, +vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16(rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8(const float16_t *rs1, +vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16(rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vloxseg8ei16(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x8_t test_vloxseg8ei16_v_u64m1x8(const uint64_t *rs1, vuint16mf4_t rs2, } vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16(vm, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg8ei32.c b/auto-generated/overloaded-api-testing/vloxseg8ei32.c index 16fe8a1e1..a8f604ef7 100644 --- a/auto-generated/overloaded-api-testing/vloxseg8ei32.c +++ b/auto-generated/overloaded-api-testing/vloxseg8ei32.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8(const float16_t *rs1, +vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32(rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8(const float16_t *rs1, +vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32(rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vloxseg8ei32(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x8_t test_vloxseg8ei32_v_u64m1x8(const uint64_t *rs1, vuint32mf2_t rs2, } vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32(vm, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg8ei64.c b/auto-generated/overloaded-api-testing/vloxseg8ei64.c index 68a9f0d05..eb65f96f0 100644 --- a/auto-generated/overloaded-api-testing/vloxseg8ei64.c +++ b/auto-generated/overloaded-api-testing/vloxseg8ei64.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8(const float16_t *rs1, +vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64(rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8(const float16_t *rs1, +vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64(rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vloxseg8ei64(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x8_t test_vloxseg8ei64_v_u64m1x8(const uint64_t *rs1, vuint64m1_t rs2, } vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64(vm, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vloxseg8ei8.c b/auto-generated/overloaded-api-testing/vloxseg8ei8.c index f73d5e71b..7664bc8e5 100644 --- a/auto-generated/overloaded-api-testing/vloxseg8ei8.c +++ b/auto-generated/overloaded-api-testing/vloxseg8ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8(const float16_t *rs1, +vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8(const float16_t *rs1, +vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8(rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8(rs1, rs2, vl); } @@ -135,19 +135,17 @@ vuint64m1x8_t test_vloxseg8ei8_v_u64m1x8(const uint64_t *rs1, vuint8mf8_t rs2, return __riscv_vloxseg8ei8(rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vlse16.c b/auto-generated/overloaded-api-testing/vlse16.c index 37ef8977c..137f745df 100644 --- a/auto-generated/overloaded-api-testing/vlse16.c +++ b/auto-generated/overloaded-api-testing/vlse16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vlse16_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vlse16_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vlse16_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vlse16_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16(vm, rs1, rs2, vl); } -vfloat16m1_t test_vlse16_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vlse16_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16(vm, rs1, rs2, vl); } -vfloat16m2_t test_vlse16_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vlse16_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16(vm, rs1, rs2, vl); } -vfloat16m4_t test_vlse16_v_f16m4_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4_t test_vlse16_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16(vm, rs1, rs2, vl); } -vfloat16m8_t test_vlse16_v_f16m8_m(vbool2_t vm, const float16_t *rs1, +vfloat16m8_t test_vlse16_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vlseg2e16.c b/auto-generated/overloaded-api-testing/vlseg2e16.c index debbee492..ee0824a6e 100644 --- a/auto-generated/overloaded-api-testing/vlseg2e16.c +++ b/auto-generated/overloaded-api-testing/vlseg2e16.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16(vm, rs1, vl); } -vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16(vm, rs1, vl); } -vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16(vm, rs1, vl); } -vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16(vm, rs1, vl); } -vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16(vm, rs1, vl); } diff --git a/auto-generated/overloaded-api-testing/vlseg2e16ff.c b/auto-generated/overloaded-api-testing/vlseg2e16ff.c index 5bb756649..c95625e16 100644 --- a/auto-generated/overloaded-api-testing/vlseg2e16ff.c +++ b/auto-generated/overloaded-api-testing/vlseg2e16ff.c @@ -5,29 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff(vm, rs1, new_vl, vl); } -vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff(vm, rs1, new_vl, vl); } -vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff(vm, rs1, new_vl, vl); } -vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff(vm, rs1, new_vl, vl); } -vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff(vm, rs1, new_vl, vl); } diff --git a/auto-generated/overloaded-api-testing/vlseg3e16.c b/auto-generated/overloaded-api-testing/vlseg3e16.c index 21d02eb68..c7cedb1ef 100644 --- a/auto-generated/overloaded-api-testing/vlseg3e16.c +++ b/auto-generated/overloaded-api-testing/vlseg3e16.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16(vm, rs1, vl); } -vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16(vm, rs1, vl); } -vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16(vm, rs1, vl); } -vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16(vm, rs1, vl); } diff --git a/auto-generated/overloaded-api-testing/vlseg3e16ff.c b/auto-generated/overloaded-api-testing/vlseg3e16ff.c index 8da7e005b..def4bb592 100644 --- a/auto-generated/overloaded-api-testing/vlseg3e16ff.c +++ b/auto-generated/overloaded-api-testing/vlseg3e16ff.c @@ -5,24 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff(vm, rs1, new_vl, vl); } -vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff(vm, rs1, new_vl, vl); } -vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff(vm, rs1, new_vl, vl); } -vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff(vm, rs1, new_vl, vl); } diff --git a/auto-generated/overloaded-api-testing/vlseg4e16.c b/auto-generated/overloaded-api-testing/vlseg4e16.c index 10b7b7ef1..2ba75526d 100644 --- a/auto-generated/overloaded-api-testing/vlseg4e16.c +++ b/auto-generated/overloaded-api-testing/vlseg4e16.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16(vm, rs1, vl); } -vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16(vm, rs1, vl); } -vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16(vm, rs1, vl); } -vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16(vm, rs1, vl); } diff --git a/auto-generated/overloaded-api-testing/vlseg4e16ff.c b/auto-generated/overloaded-api-testing/vlseg4e16ff.c index 56d2ac07e..93e0537b8 100644 --- a/auto-generated/overloaded-api-testing/vlseg4e16ff.c +++ b/auto-generated/overloaded-api-testing/vlseg4e16ff.c @@ -5,24 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff(vm, rs1, new_vl, vl); } -vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff(vm, rs1, new_vl, vl); } -vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff(vm, rs1, new_vl, vl); } -vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff(vm, rs1, new_vl, vl); } diff --git a/auto-generated/overloaded-api-testing/vlseg5e16.c b/auto-generated/overloaded-api-testing/vlseg5e16.c index 820e20a16..27457ab06 100644 --- a/auto-generated/overloaded-api-testing/vlseg5e16.c +++ b/auto-generated/overloaded-api-testing/vlseg5e16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16(vm, rs1, vl); } -vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16(vm, rs1, vl); } -vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16(vm, rs1, vl); } diff --git a/auto-generated/overloaded-api-testing/vlseg5e16ff.c b/auto-generated/overloaded-api-testing/vlseg5e16ff.c index f4b78c187..7cbab4fd6 100644 --- a/auto-generated/overloaded-api-testing/vlseg5e16ff.c +++ b/auto-generated/overloaded-api-testing/vlseg5e16ff.c @@ -5,19 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff(vm, rs1, new_vl, vl); } -vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff(vm, rs1, new_vl, vl); } -vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff(vm, rs1, new_vl, vl); } diff --git a/auto-generated/overloaded-api-testing/vlseg6e16.c b/auto-generated/overloaded-api-testing/vlseg6e16.c index 330e8ee09..aac1f84df 100644 --- a/auto-generated/overloaded-api-testing/vlseg6e16.c +++ b/auto-generated/overloaded-api-testing/vlseg6e16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16(vm, rs1, vl); } -vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16(vm, rs1, vl); } -vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16(vm, rs1, vl); } diff --git a/auto-generated/overloaded-api-testing/vlseg6e16ff.c b/auto-generated/overloaded-api-testing/vlseg6e16ff.c index 7e3346a1d..471f2082a 100644 --- a/auto-generated/overloaded-api-testing/vlseg6e16ff.c +++ b/auto-generated/overloaded-api-testing/vlseg6e16ff.c @@ -5,19 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff(vm, rs1, new_vl, vl); } -vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff(vm, rs1, new_vl, vl); } -vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff(vm, rs1, new_vl, vl); } diff --git a/auto-generated/overloaded-api-testing/vlseg7e16.c b/auto-generated/overloaded-api-testing/vlseg7e16.c index 620e5e206..adac785ad 100644 --- a/auto-generated/overloaded-api-testing/vlseg7e16.c +++ b/auto-generated/overloaded-api-testing/vlseg7e16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16(vm, rs1, vl); } -vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16(vm, rs1, vl); } -vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16(vm, rs1, vl); } diff --git a/auto-generated/overloaded-api-testing/vlseg7e16ff.c b/auto-generated/overloaded-api-testing/vlseg7e16ff.c index 885442ff4..04e7a1a75 100644 --- a/auto-generated/overloaded-api-testing/vlseg7e16ff.c +++ b/auto-generated/overloaded-api-testing/vlseg7e16ff.c @@ -5,19 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff(vm, rs1, new_vl, vl); } -vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff(vm, rs1, new_vl, vl); } -vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff(vm, rs1, new_vl, vl); } diff --git a/auto-generated/overloaded-api-testing/vlseg8e16.c b/auto-generated/overloaded-api-testing/vlseg8e16.c index 749f44c33..33ab6917e 100644 --- a/auto-generated/overloaded-api-testing/vlseg8e16.c +++ b/auto-generated/overloaded-api-testing/vlseg8e16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16(vm, rs1, vl); } -vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16(vm, rs1, vl); } -vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16(vm, rs1, vl); } diff --git a/auto-generated/overloaded-api-testing/vlseg8e16ff.c b/auto-generated/overloaded-api-testing/vlseg8e16ff.c index 8ab5dd349..79888fda2 100644 --- a/auto-generated/overloaded-api-testing/vlseg8e16ff.c +++ b/auto-generated/overloaded-api-testing/vlseg8e16ff.c @@ -5,19 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff(vm, rs1, new_vl, vl); } -vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff(vm, rs1, new_vl, vl); } -vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff(vm, rs1, new_vl, vl); } diff --git a/auto-generated/overloaded-api-testing/vlsseg2e16.c b/auto-generated/overloaded-api-testing/vlsseg2e16.c index 60251a91c..80284db63 100644 --- a/auto-generated/overloaded-api-testing/vlsseg2e16.c +++ b/auto-generated/overloaded-api-testing/vlsseg2e16.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vlsseg3e16.c b/auto-generated/overloaded-api-testing/vlsseg3e16.c index 2e06f62e8..b94a5cf14 100644 --- a/auto-generated/overloaded-api-testing/vlsseg3e16.c +++ b/auto-generated/overloaded-api-testing/vlsseg3e16.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vlsseg4e16.c b/auto-generated/overloaded-api-testing/vlsseg4e16.c index 2a5f88c15..a6eac502f 100644 --- a/auto-generated/overloaded-api-testing/vlsseg4e16.c +++ b/auto-generated/overloaded-api-testing/vlsseg4e16.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vlsseg5e16.c b/auto-generated/overloaded-api-testing/vlsseg5e16.c index 1b9bb180e..5150e9ebc 100644 --- a/auto-generated/overloaded-api-testing/vlsseg5e16.c +++ b/auto-generated/overloaded-api-testing/vlsseg5e16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vlsseg6e16.c b/auto-generated/overloaded-api-testing/vlsseg6e16.c index 79b2bc49f..ff889a828 100644 --- a/auto-generated/overloaded-api-testing/vlsseg6e16.c +++ b/auto-generated/overloaded-api-testing/vlsseg6e16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vlsseg7e16.c b/auto-generated/overloaded-api-testing/vlsseg7e16.c index b5d3a42b1..d2883a3ba 100644 --- a/auto-generated/overloaded-api-testing/vlsseg7e16.c +++ b/auto-generated/overloaded-api-testing/vlsseg7e16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vlsseg8e16.c b/auto-generated/overloaded-api-testing/vlsseg8e16.c index 52c19abd4..3ed497854 100644 --- a/auto-generated/overloaded-api-testing/vlsseg8e16.c +++ b/auto-generated/overloaded-api-testing/vlsseg8e16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxei16.c b/auto-generated/overloaded-api-testing/vluxei16.c index b33d5d482..25b1f6ee0 100644 --- a/auto-generated/overloaded-api-testing/vluxei16.c +++ b/auto-generated/overloaded-api-testing/vluxei16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei16_v_f16mf4(const float16_t *rs1, vuint16mf4_t rs2, +vfloat16mf4_t test_vluxei16_v_f16mf4(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16(rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2(const float16_t *rs1, vuint16mf2_t rs2, +vfloat16mf2_t test_vluxei16_v_f16mf2(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16(rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1(const float16_t *rs1, vuint16m1_t rs2, +vfloat16m1_t test_vluxei16_v_f16m1(const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16(rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2(const float16_t *rs1, vuint16m2_t rs2, +vfloat16m2_t test_vluxei16_v_f16m2(const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16(rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4(const float16_t *rs1, vuint16m4_t rs2, +vfloat16m4_t test_vluxei16_v_f16m4(const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16(rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8(const float16_t *rs1, vuint16m8_t rs2, +vfloat16m8_t test_vluxei16_v_f16m8(const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16(rs1, rs2, vl); } @@ -287,32 +287,32 @@ vuint64m8_t test_vluxei16_v_u64m8(const uint64_t *rs1, vuint16m2_t rs2, return __riscv_vluxei16(rs1, rs2, vl); } -vfloat16mf4_t test_vluxei16_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vluxei16_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vluxei16_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16(vm, rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vluxei16_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16(vm, rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vluxei16_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16(vm, rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4_t test_vluxei16_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16(vm, rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8_m(vbool2_t vm, const float16_t *rs1, +vfloat16m8_t test_vluxei16_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxei32.c b/auto-generated/overloaded-api-testing/vluxei32.c index b78a5fd33..da6e3ff4e 100644 --- a/auto-generated/overloaded-api-testing/vluxei32.c +++ b/auto-generated/overloaded-api-testing/vluxei32.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei32_v_f16mf4(const float16_t *rs1, vuint32mf2_t rs2, +vfloat16mf4_t test_vluxei32_v_f16mf4(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32(rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2(const float16_t *rs1, vuint32m1_t rs2, +vfloat16mf2_t test_vluxei32_v_f16mf2(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32(rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1(const float16_t *rs1, vuint32m2_t rs2, +vfloat16m1_t test_vluxei32_v_f16m1(const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32(rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2(const float16_t *rs1, vuint32m4_t rs2, +vfloat16m2_t test_vluxei32_v_f16m2(const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32(rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4(const float16_t *rs1, vuint32m8_t rs2, +vfloat16m4_t test_vluxei32_v_f16m4(const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32(rs1, rs2, vl); } @@ -263,27 +263,27 @@ vuint64m8_t test_vluxei32_v_u64m8(const uint64_t *rs1, vuint32m4_t rs2, return __riscv_vluxei32(rs1, rs2, vl); } -vfloat16mf4_t test_vluxei32_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vluxei32_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vluxei32_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32(vm, rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vluxei32_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32(vm, rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vluxei32_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32(vm, rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4_t test_vluxei32_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxei64.c b/auto-generated/overloaded-api-testing/vluxei64.c index 65a419515..d149eb16e 100644 --- a/auto-generated/overloaded-api-testing/vluxei64.c +++ b/auto-generated/overloaded-api-testing/vluxei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei64_v_f16mf4(const float16_t *rs1, vuint64m1_t rs2, +vfloat16mf4_t test_vluxei64_v_f16mf4(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64(rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2(const float16_t *rs1, vuint64m2_t rs2, +vfloat16mf2_t test_vluxei64_v_f16mf2(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64(rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1(const float16_t *rs1, vuint64m4_t rs2, +vfloat16m1_t test_vluxei64_v_f16m1(const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64(rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2(const float16_t *rs1, vuint64m8_t rs2, +vfloat16m2_t test_vluxei64_v_f16m2(const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64(rs1, rs2, vl); } @@ -224,22 +224,22 @@ vuint64m8_t test_vluxei64_v_u64m8(const uint64_t *rs1, vuint64m8_t rs2, return __riscv_vluxei64(rs1, rs2, vl); } -vfloat16mf4_t test_vluxei64_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vluxei64_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vluxei64_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64(vm, rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vluxei64_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64(vm, rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vluxei64_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxei8.c b/auto-generated/overloaded-api-testing/vluxei8.c index d90411ed0..68b6cfeb6 100644 --- a/auto-generated/overloaded-api-testing/vluxei8.c +++ b/auto-generated/overloaded-api-testing/vluxei8.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei8_v_f16mf4(const float16_t *rs1, vuint8mf8_t rs2, +vfloat16mf4_t test_vluxei8_v_f16mf4(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8(rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2(const float16_t *rs1, vuint8mf4_t rs2, +vfloat16mf2_t test_vluxei8_v_f16mf2(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8(rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1_t test_vluxei8_v_f16m1(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8(rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2(const float16_t *rs1, vuint8m1_t rs2, +vfloat16m2_t test_vluxei8_v_f16m2(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8(rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4(const float16_t *rs1, vuint8m2_t rs2, +vfloat16m4_t test_vluxei8_v_f16m4(const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8(rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8(const float16_t *rs1, vuint8m4_t rs2, +vfloat16m8_t test_vluxei8_v_f16m8(const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8(rs1, rs2, vl); } @@ -283,32 +283,32 @@ vuint64m8_t test_vluxei8_v_u64m8(const uint64_t *rs1, vuint8m1_t rs2, return __riscv_vluxei8(rs1, rs2, vl); } -vfloat16mf4_t test_vluxei8_v_f16mf4_m(vbool64_t vm, const float16_t *rs1, +vfloat16mf4_t test_vluxei8_v_f16mf4_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8(vm, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2_m(vbool32_t vm, const float16_t *rs1, +vfloat16mf2_t test_vluxei8_v_f16mf2_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8(vm, rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1_t test_vluxei8_v_f16m1_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8(vm, rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2_t test_vluxei8_v_f16m2_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8(vm, rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4_t test_vluxei8_v_f16m4_m(vbool4_t vm, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8(vm, rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8_m(vbool2_t vm, const float16_t *rs1, +vfloat16m8_t test_vluxei8_v_f16m8_m(vbool2_t vm, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg2ei16.c b/auto-generated/overloaded-api-testing/vluxseg2ei16.c index e642ae027..c06d7dddd 100644 --- a/auto-generated/overloaded-api-testing/vluxseg2ei16.c +++ b/auto-generated/overloaded-api-testing/vluxseg2ei16.c @@ -5,28 +5,28 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2(const float16_t *rs1, +vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16(rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2(const float16_t *rs1, +vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16(rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vluxseg2ei16(rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2(const float16_t *rs1, - vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2(const _Float16 *rs1, vuint16m2_t rs2, + size_t vl) { return __riscv_vluxseg2ei16(rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2(const float16_t *rs1, - vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2(const _Float16 *rs1, vuint16m4_t rs2, + size_t vl) { return __riscv_vluxseg2ei16(rs1, rs2, vl); } @@ -246,28 +246,28 @@ vuint64m4x2_t test_vluxseg2ei16_v_u64m4x2(const uint64_t *rs1, vuint16m1_t rs2, } vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16(vm, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg2ei32.c b/auto-generated/overloaded-api-testing/vluxseg2ei32.c index 88588e40a..b5a2f5906 100644 --- a/auto-generated/overloaded-api-testing/vluxseg2ei32.c +++ b/auto-generated/overloaded-api-testing/vluxseg2ei32.c @@ -5,28 +5,28 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2(const float16_t *rs1, +vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32(rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2(const float16_t *rs1, +vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32(rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vluxseg2ei32(rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2(const float16_t *rs1, - vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2(const _Float16 *rs1, vuint32m4_t rs2, + size_t vl) { return __riscv_vluxseg2ei32(rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2(const float16_t *rs1, - vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2(const _Float16 *rs1, vuint32m8_t rs2, + size_t vl) { return __riscv_vluxseg2ei32(rs1, rs2, vl); } @@ -236,28 +236,28 @@ vuint64m4x2_t test_vluxseg2ei32_v_u64m4x2(const uint64_t *rs1, vuint32m2_t rs2, } vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32(vm, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg2ei64.c b/auto-generated/overloaded-api-testing/vluxseg2ei64.c index d5ffa9c54..e78029bdf 100644 --- a/auto-generated/overloaded-api-testing/vluxseg2ei64.c +++ b/auto-generated/overloaded-api-testing/vluxseg2ei64.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2(const float16_t *rs1, +vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64(rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2(const float16_t *rs1, +vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64(rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vluxseg2ei64(rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2(const float16_t *rs1, - vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2(const _Float16 *rs1, vuint64m8_t rs2, + size_t vl) { return __riscv_vluxseg2ei64(rs1, rs2, vl); } @@ -211,23 +211,23 @@ vuint64m4x2_t test_vluxseg2ei64_v_u64m4x2(const uint64_t *rs1, vuint64m4_t rs2, } vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64(vm, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg2ei8.c b/auto-generated/overloaded-api-testing/vluxseg2ei8.c index 0d2648336..05a890334 100644 --- a/auto-generated/overloaded-api-testing/vluxseg2ei8.c +++ b/auto-generated/overloaded-api-testing/vluxseg2ei8.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2(const float16_t *rs1, +vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8(rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2(const float16_t *rs1, +vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8(rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8(rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2(const float16_t *rs1, vuint8m1_t rs2, +vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8(rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2(const float16_t *rs1, vuint8m2_t rs2, +vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2(const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8(rs1, rs2, vl); } @@ -245,29 +245,27 @@ vuint64m4x2_t test_vluxseg2ei8_v_u64m4x2(const uint64_t *rs1, vuint8mf2_t rs2, return __riscv_vluxseg2ei8(rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8(vm, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8(vm, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8(vm, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8(vm, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_m(vbool4_t vm, const float16_t *rs1, +vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_m(vbool4_t vm, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg3ei16.c b/auto-generated/overloaded-api-testing/vluxseg3ei16.c index 31ca2c105..dcb7b162e 100644 --- a/auto-generated/overloaded-api-testing/vluxseg3ei16.c +++ b/auto-generated/overloaded-api-testing/vluxseg3ei16.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3(const float16_t *rs1, +vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16(rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3(const float16_t *rs1, +vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16(rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vluxseg3ei16(rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3(const float16_t *rs1, - vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3(const _Float16 *rs1, vuint16m2_t rs2, + size_t vl) { return __riscv_vluxseg3ei16(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m2x3_t test_vluxseg3ei16_v_u64m2x3(const uint64_t *rs1, vuint16mf2_t rs2, } vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16(vm, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg3ei32.c b/auto-generated/overloaded-api-testing/vluxseg3ei32.c index 45eb593cd..390c9059c 100644 --- a/auto-generated/overloaded-api-testing/vluxseg3ei32.c +++ b/auto-generated/overloaded-api-testing/vluxseg3ei32.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3(const float16_t *rs1, +vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32(rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3(const float16_t *rs1, +vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32(rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vluxseg3ei32(rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3(const float16_t *rs1, - vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3(const _Float16 *rs1, vuint32m4_t rs2, + size_t vl) { return __riscv_vluxseg3ei32(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m2x3_t test_vluxseg3ei32_v_u64m2x3(const uint64_t *rs1, vuint32m1_t rs2, } vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32(vm, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg3ei64.c b/auto-generated/overloaded-api-testing/vluxseg3ei64.c index 3ca1ecf9e..382a86639 100644 --- a/auto-generated/overloaded-api-testing/vluxseg3ei64.c +++ b/auto-generated/overloaded-api-testing/vluxseg3ei64.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3(const float16_t *rs1, +vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64(rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3(const float16_t *rs1, +vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64(rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vluxseg3ei64(rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3(const float16_t *rs1, - vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3(const _Float16 *rs1, vuint64m8_t rs2, + size_t vl) { return __riscv_vluxseg3ei64(rs1, rs2, vl); } @@ -181,23 +181,23 @@ vuint64m2x3_t test_vluxseg3ei64_v_u64m2x3(const uint64_t *rs1, vuint64m2_t rs2, } vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64(vm, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg3ei8.c b/auto-generated/overloaded-api-testing/vluxseg3ei8.c index 549077e47..d8f9e2136 100644 --- a/auto-generated/overloaded-api-testing/vluxseg3ei8.c +++ b/auto-generated/overloaded-api-testing/vluxseg3ei8.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3(const float16_t *rs1, +vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8(rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3(const float16_t *rs1, +vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8(rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8(rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3(const float16_t *rs1, vuint8m1_t rs2, +vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8(rs1, rs2, vl); } @@ -190,24 +190,22 @@ vuint64m2x3_t test_vluxseg3ei8_v_u64m2x3(const uint64_t *rs1, vuint8mf4_t rs2, return __riscv_vluxseg3ei8(rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8(vm, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8(vm, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8(vm, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg4ei16.c b/auto-generated/overloaded-api-testing/vluxseg4ei16.c index 219c18cc9..ddc9ec95b 100644 --- a/auto-generated/overloaded-api-testing/vluxseg4ei16.c +++ b/auto-generated/overloaded-api-testing/vluxseg4ei16.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4(const float16_t *rs1, +vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16(rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4(const float16_t *rs1, +vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16(rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vluxseg4ei16(rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4(const float16_t *rs1, - vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4(const _Float16 *rs1, vuint16m2_t rs2, + size_t vl) { return __riscv_vluxseg4ei16(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m2x4_t test_vluxseg4ei16_v_u64m2x4(const uint64_t *rs1, vuint16mf2_t rs2, } vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16(vm, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg4ei32.c b/auto-generated/overloaded-api-testing/vluxseg4ei32.c index 6aab545e8..8fe37ab1b 100644 --- a/auto-generated/overloaded-api-testing/vluxseg4ei32.c +++ b/auto-generated/overloaded-api-testing/vluxseg4ei32.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4(const float16_t *rs1, +vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32(rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4(const float16_t *rs1, +vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32(rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vluxseg4ei32(rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4(const float16_t *rs1, - vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4(const _Float16 *rs1, vuint32m4_t rs2, + size_t vl) { return __riscv_vluxseg4ei32(rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m2x4_t test_vluxseg4ei32_v_u64m2x4(const uint64_t *rs1, vuint32m1_t rs2, } vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32(vm, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg4ei64.c b/auto-generated/overloaded-api-testing/vluxseg4ei64.c index ca2747c94..c9fb228e2 100644 --- a/auto-generated/overloaded-api-testing/vluxseg4ei64.c +++ b/auto-generated/overloaded-api-testing/vluxseg4ei64.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4(const float16_t *rs1, +vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64(rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4(const float16_t *rs1, +vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64(rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vluxseg4ei64(rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4(const float16_t *rs1, - vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4(const _Float16 *rs1, vuint64m8_t rs2, + size_t vl) { return __riscv_vluxseg4ei64(rs1, rs2, vl); } @@ -181,23 +181,23 @@ vuint64m2x4_t test_vluxseg4ei64_v_u64m2x4(const uint64_t *rs1, vuint64m2_t rs2, } vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64(vm, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg4ei8.c b/auto-generated/overloaded-api-testing/vluxseg4ei8.c index 7fee1f2f8..cdd76a7e7 100644 --- a/auto-generated/overloaded-api-testing/vluxseg4ei8.c +++ b/auto-generated/overloaded-api-testing/vluxseg4ei8.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4(const float16_t *rs1, +vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8(rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4(const float16_t *rs1, +vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8(rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8(rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4(const float16_t *rs1, vuint8m1_t rs2, +vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4(const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8(rs1, rs2, vl); } @@ -190,24 +190,22 @@ vuint64m2x4_t test_vluxseg4ei8_v_u64m2x4(const uint64_t *rs1, vuint8mf4_t rs2, return __riscv_vluxseg4ei8(rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8(vm, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8(vm, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8(vm, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_m(vbool8_t vm, const float16_t *rs1, +vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_m(vbool8_t vm, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg5ei16.c b/auto-generated/overloaded-api-testing/vluxseg5ei16.c index c6c51e1c6..e321f3f34 100644 --- a/auto-generated/overloaded-api-testing/vluxseg5ei16.c +++ b/auto-generated/overloaded-api-testing/vluxseg5ei16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5(const float16_t *rs1, +vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16(rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5(const float16_t *rs1, +vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16(rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vluxseg5ei16(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x5_t test_vluxseg5ei16_v_u64m1x5(const uint64_t *rs1, vuint16mf4_t rs2, } vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16(vm, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg5ei32.c b/auto-generated/overloaded-api-testing/vluxseg5ei32.c index 2608bea98..a8eebd790 100644 --- a/auto-generated/overloaded-api-testing/vluxseg5ei32.c +++ b/auto-generated/overloaded-api-testing/vluxseg5ei32.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5(const float16_t *rs1, +vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32(rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5(const float16_t *rs1, +vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32(rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vluxseg5ei32(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x5_t test_vluxseg5ei32_v_u64m1x5(const uint64_t *rs1, vuint32mf2_t rs2, } vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32(vm, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg5ei64.c b/auto-generated/overloaded-api-testing/vluxseg5ei64.c index 3cab70747..c218479fe 100644 --- a/auto-generated/overloaded-api-testing/vluxseg5ei64.c +++ b/auto-generated/overloaded-api-testing/vluxseg5ei64.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5(const float16_t *rs1, +vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64(rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5(const float16_t *rs1, +vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64(rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vluxseg5ei64(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x5_t test_vluxseg5ei64_v_u64m1x5(const uint64_t *rs1, vuint64m1_t rs2, } vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64(vm, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg5ei8.c b/auto-generated/overloaded-api-testing/vluxseg5ei8.c index f18fa4266..159416c5c 100644 --- a/auto-generated/overloaded-api-testing/vluxseg5ei8.c +++ b/auto-generated/overloaded-api-testing/vluxseg5ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5(const float16_t *rs1, +vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8(rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5(const float16_t *rs1, +vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8(rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8(rs1, rs2, vl); } @@ -135,19 +135,17 @@ vuint64m1x5_t test_vluxseg5ei8_v_u64m1x5(const uint64_t *rs1, vuint8mf8_t rs2, return __riscv_vluxseg5ei8(rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8(vm, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8(vm, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg6ei16.c b/auto-generated/overloaded-api-testing/vluxseg6ei16.c index e8b97bbbd..5f4f25ca9 100644 --- a/auto-generated/overloaded-api-testing/vluxseg6ei16.c +++ b/auto-generated/overloaded-api-testing/vluxseg6ei16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6(const float16_t *rs1, +vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16(rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6(const float16_t *rs1, +vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16(rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vluxseg6ei16(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x6_t test_vluxseg6ei16_v_u64m1x6(const uint64_t *rs1, vuint16mf4_t rs2, } vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16(vm, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg6ei32.c b/auto-generated/overloaded-api-testing/vluxseg6ei32.c index 097c29a03..37744db2b 100644 --- a/auto-generated/overloaded-api-testing/vluxseg6ei32.c +++ b/auto-generated/overloaded-api-testing/vluxseg6ei32.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6(const float16_t *rs1, +vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32(rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6(const float16_t *rs1, +vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32(rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vluxseg6ei32(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x6_t test_vluxseg6ei32_v_u64m1x6(const uint64_t *rs1, vuint32mf2_t rs2, } vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32(vm, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg6ei64.c b/auto-generated/overloaded-api-testing/vluxseg6ei64.c index 7e74625ce..f148bc21c 100644 --- a/auto-generated/overloaded-api-testing/vluxseg6ei64.c +++ b/auto-generated/overloaded-api-testing/vluxseg6ei64.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6(const float16_t *rs1, +vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64(rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6(const float16_t *rs1, +vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64(rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vluxseg6ei64(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x6_t test_vluxseg6ei64_v_u64m1x6(const uint64_t *rs1, vuint64m1_t rs2, } vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64(vm, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg6ei8.c b/auto-generated/overloaded-api-testing/vluxseg6ei8.c index 65c1aff6e..3bae9cb21 100644 --- a/auto-generated/overloaded-api-testing/vluxseg6ei8.c +++ b/auto-generated/overloaded-api-testing/vluxseg6ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6(const float16_t *rs1, +vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8(rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6(const float16_t *rs1, +vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8(rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8(rs1, rs2, vl); } @@ -135,19 +135,17 @@ vuint64m1x6_t test_vluxseg6ei8_v_u64m1x6(const uint64_t *rs1, vuint8mf8_t rs2, return __riscv_vluxseg6ei8(rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8(vm, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8(vm, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg7ei16.c b/auto-generated/overloaded-api-testing/vluxseg7ei16.c index c0b7ed9b8..be1e49112 100644 --- a/auto-generated/overloaded-api-testing/vluxseg7ei16.c +++ b/auto-generated/overloaded-api-testing/vluxseg7ei16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7(const float16_t *rs1, +vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16(rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7(const float16_t *rs1, +vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16(rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vluxseg7ei16(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x7_t test_vluxseg7ei16_v_u64m1x7(const uint64_t *rs1, vuint16mf4_t rs2, } vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16(vm, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg7ei32.c b/auto-generated/overloaded-api-testing/vluxseg7ei32.c index 3b3910cda..a4df57cf0 100644 --- a/auto-generated/overloaded-api-testing/vluxseg7ei32.c +++ b/auto-generated/overloaded-api-testing/vluxseg7ei32.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7(const float16_t *rs1, +vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32(rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7(const float16_t *rs1, +vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32(rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vluxseg7ei32(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x7_t test_vluxseg7ei32_v_u64m1x7(const uint64_t *rs1, vuint32mf2_t rs2, } vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32(vm, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg7ei64.c b/auto-generated/overloaded-api-testing/vluxseg7ei64.c index 9068d0dea..bac15e201 100644 --- a/auto-generated/overloaded-api-testing/vluxseg7ei64.c +++ b/auto-generated/overloaded-api-testing/vluxseg7ei64.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7(const float16_t *rs1, +vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64(rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7(const float16_t *rs1, +vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64(rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vluxseg7ei64(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x7_t test_vluxseg7ei64_v_u64m1x7(const uint64_t *rs1, vuint64m1_t rs2, } vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64(vm, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg7ei8.c b/auto-generated/overloaded-api-testing/vluxseg7ei8.c index 201583164..0416f760e 100644 --- a/auto-generated/overloaded-api-testing/vluxseg7ei8.c +++ b/auto-generated/overloaded-api-testing/vluxseg7ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7(const float16_t *rs1, +vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8(rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7(const float16_t *rs1, +vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8(rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8(rs1, rs2, vl); } @@ -135,19 +135,17 @@ vuint64m1x7_t test_vluxseg7ei8_v_u64m1x7(const uint64_t *rs1, vuint8mf8_t rs2, return __riscv_vluxseg7ei8(rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8(vm, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8(vm, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg8ei16.c b/auto-generated/overloaded-api-testing/vluxseg8ei16.c index 750e218ae..e4f363b73 100644 --- a/auto-generated/overloaded-api-testing/vluxseg8ei16.c +++ b/auto-generated/overloaded-api-testing/vluxseg8ei16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8(const float16_t *rs1, +vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8(const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16(rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8(const float16_t *rs1, +vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8(const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16(rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8(const float16_t *rs1, - vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8(const _Float16 *rs1, vuint16m1_t rs2, + size_t vl) { return __riscv_vluxseg8ei16(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x8_t test_vluxseg8ei16_v_u64m1x8(const uint64_t *rs1, vuint16mf4_t rs2, } vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16(vm, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg8ei32.c b/auto-generated/overloaded-api-testing/vluxseg8ei32.c index a7e960f64..e30026b3b 100644 --- a/auto-generated/overloaded-api-testing/vluxseg8ei32.c +++ b/auto-generated/overloaded-api-testing/vluxseg8ei32.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8(const float16_t *rs1, +vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8(const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32(rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8(const float16_t *rs1, +vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8(const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32(rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8(const float16_t *rs1, - vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8(const _Float16 *rs1, vuint32m2_t rs2, + size_t vl) { return __riscv_vluxseg8ei32(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x8_t test_vluxseg8ei32_v_u64m1x8(const uint64_t *rs1, vuint32mf2_t rs2, } vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32(vm, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg8ei64.c b/auto-generated/overloaded-api-testing/vluxseg8ei64.c index d39b5500c..2616d0ac2 100644 --- a/auto-generated/overloaded-api-testing/vluxseg8ei64.c +++ b/auto-generated/overloaded-api-testing/vluxseg8ei64.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8(const float16_t *rs1, +vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8(const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64(rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8(const float16_t *rs1, +vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8(const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64(rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8(const float16_t *rs1, - vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8(const _Float16 *rs1, vuint64m4_t rs2, + size_t vl) { return __riscv_vluxseg8ei64(rs1, rs2, vl); } @@ -136,18 +136,18 @@ vuint64m1x8_t test_vluxseg8ei64_v_u64m1x8(const uint64_t *rs1, vuint64m1_t rs2, } vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64(vm, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vluxseg8ei8.c b/auto-generated/overloaded-api-testing/vluxseg8ei8.c index 35995c820..d4d0e876e 100644 --- a/auto-generated/overloaded-api-testing/vluxseg8ei8.c +++ b/auto-generated/overloaded-api-testing/vluxseg8ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8(const float16_t *rs1, +vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8(const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8(rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8(const float16_t *rs1, +vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8(const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8(rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8(const float16_t *rs1, vuint8mf2_t rs2, +vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8(const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8(rs1, rs2, vl); } @@ -135,19 +135,17 @@ vuint64m1x8_t test_vluxseg8ei8_v_u64m1x8(const uint64_t *rs1, vuint8mf8_t rs2, return __riscv_vluxseg8ei8(rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_m(vbool64_t vm, - const float16_t *rs1, +vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_m(vbool64_t vm, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8(vm, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_m(vbool32_t vm, - const float16_t *rs1, +vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_m(vbool32_t vm, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8(vm, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_m(vbool16_t vm, const float16_t *rs1, +vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_m(vbool16_t vm, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8(vm, rs1, rs2, vl); } diff --git a/auto-generated/overloaded-api-testing/vse16.c b/auto-generated/overloaded-api-testing/vse16.c index bc322c3e8..59c8d2009 100644 --- a/auto-generated/overloaded-api-testing/vse16.c +++ b/auto-generated/overloaded-api-testing/vse16.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vse16_v_f16mf4(float16_t *rs1, vfloat16mf4_t vs3, size_t vl) { +void test_vse16_v_f16mf4(_Float16 *rs1, vfloat16mf4_t vs3, size_t vl) { return __riscv_vse16(rs1, vs3, vl); } -void test_vse16_v_f16mf2(float16_t *rs1, vfloat16mf2_t vs3, size_t vl) { +void test_vse16_v_f16mf2(_Float16 *rs1, vfloat16mf2_t vs3, size_t vl) { return __riscv_vse16(rs1, vs3, vl); } -void test_vse16_v_f16m1(float16_t *rs1, vfloat16m1_t vs3, size_t vl) { +void test_vse16_v_f16m1(_Float16 *rs1, vfloat16m1_t vs3, size_t vl) { return __riscv_vse16(rs1, vs3, vl); } -void test_vse16_v_f16m2(float16_t *rs1, vfloat16m2_t vs3, size_t vl) { +void test_vse16_v_f16m2(_Float16 *rs1, vfloat16m2_t vs3, size_t vl) { return __riscv_vse16(rs1, vs3, vl); } -void test_vse16_v_f16m4(float16_t *rs1, vfloat16m4_t vs3, size_t vl) { +void test_vse16_v_f16m4(_Float16 *rs1, vfloat16m4_t vs3, size_t vl) { return __riscv_vse16(rs1, vs3, vl); } -void test_vse16_v_f16m8(float16_t *rs1, vfloat16m8_t vs3, size_t vl) { +void test_vse16_v_f16m8(_Float16 *rs1, vfloat16m8_t vs3, size_t vl) { return __riscv_vse16(rs1, vs3, vl); } @@ -77,32 +77,32 @@ void test_vse16_v_u16m8(uint16_t *rs1, vuint16m8_t vs3, size_t vl) { return __riscv_vse16(rs1, vs3, vl); } -void test_vse16_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vfloat16mf4_t vs3, +void test_vse16_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4_t vs3, size_t vl) { return __riscv_vse16(vm, rs1, vs3, vl); } -void test_vse16_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vfloat16mf2_t vs3, +void test_vse16_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2_t vs3, size_t vl) { return __riscv_vse16(vm, rs1, vs3, vl); } -void test_vse16_v_f16m1_m(vbool16_t vm, float16_t *rs1, vfloat16m1_t vs3, +void test_vse16_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vfloat16m1_t vs3, size_t vl) { return __riscv_vse16(vm, rs1, vs3, vl); } -void test_vse16_v_f16m2_m(vbool8_t vm, float16_t *rs1, vfloat16m2_t vs3, +void test_vse16_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vfloat16m2_t vs3, size_t vl) { return __riscv_vse16(vm, rs1, vs3, vl); } -void test_vse16_v_f16m4_m(vbool4_t vm, float16_t *rs1, vfloat16m4_t vs3, +void test_vse16_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vfloat16m4_t vs3, size_t vl) { return __riscv_vse16(vm, rs1, vs3, vl); } -void test_vse16_v_f16m8_m(vbool2_t vm, float16_t *rs1, vfloat16m8_t vs3, +void test_vse16_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vfloat16m8_t vs3, size_t vl) { return __riscv_vse16(vm, rs1, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxei16.c b/auto-generated/overloaded-api-testing/vsoxei16.c index b78c40cd5..84050405d 100644 --- a/auto-generated/overloaded-api-testing/vsoxei16.c +++ b/auto-generated/overloaded-api-testing/vsoxei16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxei16_v_f16mf4(float16_t *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, +void test_vsoxei16_v_f16mf4(_Float16 *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei16(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16mf2(float16_t *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, +void test_vsoxei16_v_f16mf2(_Float16 *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei16(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m1(float16_t *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, +void test_vsoxei16_v_f16m1(_Float16 *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei16(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m2(float16_t *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, +void test_vsoxei16_v_f16m2(_Float16 *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei16(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m4(float16_t *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, +void test_vsoxei16_v_f16m4(_Float16 *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei16(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m8(float16_t *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, +void test_vsoxei16_v_f16m8(_Float16 *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsoxei16(rs1, rs2, vs3, vl); } @@ -290,32 +290,32 @@ void test_vsoxei16_v_u64m8(uint64_t *rs1, vuint16m2_t rs2, vuint64m8_t vs3, return __riscv_vsoxei16(rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t rs2, +void test_vsoxei16_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei16(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t rs2, +void test_vsoxei16_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei16(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint16m1_t rs2, +void test_vsoxei16_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei16(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint16m2_t rs2, +void test_vsoxei16_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei16(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint16m4_t rs2, +void test_vsoxei16_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei16(vm, rs1, rs2, vs3, vl); } -void test_vsoxei16_v_f16m8_m(vbool2_t vm, float16_t *rs1, vuint16m8_t rs2, +void test_vsoxei16_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsoxei16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxei32.c b/auto-generated/overloaded-api-testing/vsoxei32.c index 7a92f9f39..2e5b0c8ef 100644 --- a/auto-generated/overloaded-api-testing/vsoxei32.c +++ b/auto-generated/overloaded-api-testing/vsoxei32.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxei32_v_f16mf4(float16_t *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, +void test_vsoxei32_v_f16mf4(_Float16 *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei32(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16mf2(float16_t *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, +void test_vsoxei32_v_f16mf2(_Float16 *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei32(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m1(float16_t *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, +void test_vsoxei32_v_f16m1(_Float16 *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei32(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m2(float16_t *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, +void test_vsoxei32_v_f16m2(_Float16 *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei32(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m4(float16_t *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, +void test_vsoxei32_v_f16m4(_Float16 *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei32(rs1, rs2, vs3, vl); } @@ -265,27 +265,27 @@ void test_vsoxei32_v_u64m8(uint64_t *rs1, vuint32m4_t rs2, vuint64m8_t vs3, return __riscv_vsoxei32(rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t rs2, +void test_vsoxei32_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei32(vm, rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint32m1_t rs2, +void test_vsoxei32_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei32(vm, rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint32m2_t rs2, +void test_vsoxei32_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei32(vm, rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint32m4_t rs2, +void test_vsoxei32_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei32(vm, rs1, rs2, vs3, vl); } -void test_vsoxei32_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint32m8_t rs2, +void test_vsoxei32_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei32(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxei64.c b/auto-generated/overloaded-api-testing/vsoxei64.c index 912139399..799d75a64 100644 --- a/auto-generated/overloaded-api-testing/vsoxei64.c +++ b/auto-generated/overloaded-api-testing/vsoxei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxei64_v_f16mf4(float16_t *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, +void test_vsoxei64_v_f16mf4(_Float16 *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei64(rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16mf2(float16_t *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, +void test_vsoxei64_v_f16mf2(_Float16 *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei64(rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16m1(float16_t *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, +void test_vsoxei64_v_f16m1(_Float16 *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei64(rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16m2(float16_t *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, +void test_vsoxei64_v_f16m2(_Float16 *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei64(rs1, rs2, vs3, vl); } @@ -225,22 +225,22 @@ void test_vsoxei64_v_u64m8(uint64_t *rs1, vuint64m8_t rs2, vuint64m8_t vs3, return __riscv_vsoxei64(rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint64m1_t rs2, +void test_vsoxei64_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei64(vm, rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint64m2_t rs2, +void test_vsoxei64_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei64(vm, rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint64m4_t rs2, +void test_vsoxei64_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei64(vm, rs1, rs2, vs3, vl); } -void test_vsoxei64_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint64m8_t rs2, +void test_vsoxei64_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei64(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxei8.c b/auto-generated/overloaded-api-testing/vsoxei8.c index 003666d82..105758116 100644 --- a/auto-generated/overloaded-api-testing/vsoxei8.c +++ b/auto-generated/overloaded-api-testing/vsoxei8.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxei8_v_f16mf4(float16_t *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, +void test_vsoxei8_v_f16mf4(_Float16 *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei8(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16mf2(float16_t *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, +void test_vsoxei8_v_f16mf2(_Float16 *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei8(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m1(float16_t *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, +void test_vsoxei8_v_f16m1(_Float16 *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei8(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m2(float16_t *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, +void test_vsoxei8_v_f16m2(_Float16 *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei8(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m4(float16_t *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, +void test_vsoxei8_v_f16m4(_Float16 *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei8(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m8(float16_t *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, +void test_vsoxei8_v_f16m8(_Float16 *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsoxei8(rs1, rs2, vs3, vl); } @@ -300,32 +300,32 @@ void test_vsoxei8_v_u64m8(uint64_t *rs1, vuint8m1_t rs2, vuint64m8_t vs3, return __riscv_vsoxei8(rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t rs2, +void test_vsoxei8_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsoxei8(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t rs2, +void test_vsoxei8_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsoxei8(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t rs2, +void test_vsoxei8_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsoxei8(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint8m1_t rs2, +void test_vsoxei8_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsoxei8(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint8m2_t rs2, +void test_vsoxei8_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsoxei8(vm, rs1, rs2, vs3, vl); } -void test_vsoxei8_v_f16m8_m(vbool2_t vm, float16_t *rs1, vuint8m4_t rs2, +void test_vsoxei8_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsoxei8(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg2ei16.c b/auto-generated/overloaded-api-testing/vsoxseg2ei16.c index f85bbffef..d72b397f0 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg2ei16.c +++ b/auto-generated/overloaded-api-testing/vsoxseg2ei16.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg2ei16_v_f16mf4x2(float16_t *rs1, vuint16mf4_t vs2, +void test_vsoxseg2ei16_v_f16mf4x2(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16mf2x2(float16_t *rs1, vuint16mf2_t vs2, +void test_vsoxseg2ei16_v_f16mf2x2(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m1x2(float16_t *rs1, vuint16m1_t vs2, +void test_vsoxseg2ei16_v_f16m1x2(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m2x2(float16_t *rs1, vuint16m2_t vs2, +void test_vsoxseg2ei16_v_f16m2x2(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m4x2(float16_t *rs1, vuint16m4_t vs2, +void test_vsoxseg2ei16_v_f16m4x2(_Float16 *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(rs1, vs2, vs3, vl); } @@ -245,30 +245,29 @@ void test_vsoxseg2ei16_v_u64m4x2(uint64_t *rs1, vuint16m1_t vs2, return __riscv_vsoxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg2ei16_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg2ei16_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x2_t vs3, - size_t vl) { +void test_vsoxseg2ei16_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, +void test_vsoxseg2ei16_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei16_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint16m4_t vs2, +void test_vsoxseg2ei16_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg2ei32.c b/auto-generated/overloaded-api-testing/vsoxseg2ei32.c index 4fd78454e..262efc721 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg2ei32.c +++ b/auto-generated/overloaded-api-testing/vsoxseg2ei32.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg2ei32_v_f16mf4x2(float16_t *rs1, vuint32mf2_t vs2, +void test_vsoxseg2ei32_v_f16mf4x2(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16mf2x2(float16_t *rs1, vuint32m1_t vs2, +void test_vsoxseg2ei32_v_f16mf2x2(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m1x2(float16_t *rs1, vuint32m2_t vs2, +void test_vsoxseg2ei32_v_f16m1x2(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m2x2(float16_t *rs1, vuint32m4_t vs2, +void test_vsoxseg2ei32_v_f16m2x2(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m4x2(float16_t *rs1, vuint32m8_t vs2, +void test_vsoxseg2ei32_v_f16m4x2(_Float16 *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(rs1, vs2, vs3, vl); } @@ -235,30 +235,29 @@ void test_vsoxseg2ei32_v_u64m4x2(uint64_t *rs1, vuint32m2_t vs2, return __riscv_vsoxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg2ei32_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg2ei32_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x2_t vs3, - size_t vl) { +void test_vsoxseg2ei32_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, +void test_vsoxseg2ei32_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei32_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint32m8_t vs2, +void test_vsoxseg2ei32_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg2ei64.c b/auto-generated/overloaded-api-testing/vsoxseg2ei64.c index 77270e09f..8c897ca48 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg2ei64.c +++ b/auto-generated/overloaded-api-testing/vsoxseg2ei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg2ei64_v_f16mf4x2(float16_t *rs1, vuint64m1_t vs2, +void test_vsoxseg2ei64_v_f16mf4x2(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16mf2x2(float16_t *rs1, vuint64m2_t vs2, +void test_vsoxseg2ei64_v_f16mf2x2(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16m1x2(float16_t *rs1, vuint64m4_t vs2, +void test_vsoxseg2ei64_v_f16m1x2(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16m2x2(float16_t *rs1, vuint64m8_t vs2, +void test_vsoxseg2ei64_v_f16m2x2(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64(rs1, vs2, vs3, vl); } @@ -210,25 +210,24 @@ void test_vsoxseg2ei64_v_u64m4x2(uint64_t *rs1, vuint64m4_t vs2, return __riscv_vsoxseg2ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg2ei64_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg2ei64_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x2_t vs3, - size_t vl) { +void test_vsoxseg2ei64_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei64_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, +void test_vsoxseg2ei64_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg2ei8.c b/auto-generated/overloaded-api-testing/vsoxseg2ei8.c index 0e26cb6da..be2bf83b4 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg2ei8.c +++ b/auto-generated/overloaded-api-testing/vsoxseg2ei8.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg2ei8_v_f16mf4x2(float16_t *rs1, vuint8mf8_t vs2, +void test_vsoxseg2ei8_v_f16mf4x2(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16mf2x2(float16_t *rs1, vuint8mf4_t vs2, +void test_vsoxseg2ei8_v_f16mf2x2(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m1x2(float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg2ei8_v_f16m1x2(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m2x2(float16_t *rs1, vuint8m1_t vs2, +void test_vsoxseg2ei8_v_f16m2x2(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m4x2(float16_t *rs1, vuint8m2_t vs2, +void test_vsoxseg2ei8_v_f16m4x2(_Float16 *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(rs1, vs2, vs3, vl); } @@ -245,29 +245,27 @@ void test_vsoxseg2ei8_v_u64m4x2(uint64_t *rs1, vuint8mf2_t vs2, return __riscv_vsoxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x2_t vs3, - size_t vl) { +void test_vsoxseg2ei8_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x2_t vs3, - size_t vl) { +void test_vsoxseg2ei8_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg2ei8_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, +void test_vsoxseg2ei8_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg2ei8_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint8m2_t vs2, +void test_vsoxseg2ei8_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsoxseg2ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg3ei16.c b/auto-generated/overloaded-api-testing/vsoxseg3ei16.c index abcdb339c..6e01f294b 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg3ei16.c +++ b/auto-generated/overloaded-api-testing/vsoxseg3ei16.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg3ei16_v_f16mf4x3(float16_t *rs1, vuint16mf4_t vs2, +void test_vsoxseg3ei16_v_f16mf4x3(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16mf2x3(float16_t *rs1, vuint16mf2_t vs2, +void test_vsoxseg3ei16_v_f16mf2x3(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16m1x3(float16_t *rs1, vuint16m1_t vs2, +void test_vsoxseg3ei16_v_f16m1x3(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16m2x3(float16_t *rs1, vuint16m2_t vs2, +void test_vsoxseg3ei16_v_f16m2x3(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16(rs1, vs2, vs3, vl); } @@ -190,25 +190,24 @@ void test_vsoxseg3ei16_v_u64m2x3(uint64_t *rs1, vuint16mf2_t vs2, return __riscv_vsoxseg3ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg3ei16_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg3ei16_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x3_t vs3, - size_t vl) { +void test_vsoxseg3ei16_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei16_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, +void test_vsoxseg3ei16_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg3ei32.c b/auto-generated/overloaded-api-testing/vsoxseg3ei32.c index 3b18feb5e..bed99c418 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg3ei32.c +++ b/auto-generated/overloaded-api-testing/vsoxseg3ei32.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg3ei32_v_f16mf4x3(float16_t *rs1, vuint32mf2_t vs2, +void test_vsoxseg3ei32_v_f16mf4x3(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16mf2x3(float16_t *rs1, vuint32m1_t vs2, +void test_vsoxseg3ei32_v_f16mf2x3(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16m1x3(float16_t *rs1, vuint32m2_t vs2, +void test_vsoxseg3ei32_v_f16m1x3(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16m2x3(float16_t *rs1, vuint32m4_t vs2, +void test_vsoxseg3ei32_v_f16m2x3(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32(rs1, vs2, vs3, vl); } @@ -190,25 +190,24 @@ void test_vsoxseg3ei32_v_u64m2x3(uint64_t *rs1, vuint32m1_t vs2, return __riscv_vsoxseg3ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg3ei32_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg3ei32_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x3_t vs3, - size_t vl) { +void test_vsoxseg3ei32_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei32_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, +void test_vsoxseg3ei32_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg3ei64.c b/auto-generated/overloaded-api-testing/vsoxseg3ei64.c index 05d13d27a..ad3f3decb 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg3ei64.c +++ b/auto-generated/overloaded-api-testing/vsoxseg3ei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg3ei64_v_f16mf4x3(float16_t *rs1, vuint64m1_t vs2, +void test_vsoxseg3ei64_v_f16mf4x3(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16mf2x3(float16_t *rs1, vuint64m2_t vs2, +void test_vsoxseg3ei64_v_f16mf2x3(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16m1x3(float16_t *rs1, vuint64m4_t vs2, +void test_vsoxseg3ei64_v_f16m1x3(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16m2x3(float16_t *rs1, vuint64m8_t vs2, +void test_vsoxseg3ei64_v_f16m2x3(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64(rs1, vs2, vs3, vl); } @@ -180,25 +180,24 @@ void test_vsoxseg3ei64_v_u64m2x3(uint64_t *rs1, vuint64m2_t vs2, return __riscv_vsoxseg3ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg3ei64_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg3ei64_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x3_t vs3, - size_t vl) { +void test_vsoxseg3ei64_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei64_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, +void test_vsoxseg3ei64_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg3ei8.c b/auto-generated/overloaded-api-testing/vsoxseg3ei8.c index 29857253f..f4a90d2b3 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg3ei8.c +++ b/auto-generated/overloaded-api-testing/vsoxseg3ei8.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg3ei8_v_f16mf4x3(float16_t *rs1, vuint8mf8_t vs2, +void test_vsoxseg3ei8_v_f16mf4x3(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16mf2x3(float16_t *rs1, vuint8mf4_t vs2, +void test_vsoxseg3ei8_v_f16mf2x3(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16m1x3(float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg3ei8_v_f16m1x3(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16m2x3(float16_t *rs1, vuint8m1_t vs2, +void test_vsoxseg3ei8_v_f16m2x3(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8(rs1, vs2, vs3, vl); } @@ -190,24 +190,22 @@ void test_vsoxseg3ei8_v_u64m2x3(uint64_t *rs1, vuint8mf4_t vs2, return __riscv_vsoxseg3ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x3_t vs3, - size_t vl) { +void test_vsoxseg3ei8_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x3_t vs3, - size_t vl) { +void test_vsoxseg3ei8_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg3ei8_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg3ei8_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, +void test_vsoxseg3ei8_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsoxseg3ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg4ei16.c b/auto-generated/overloaded-api-testing/vsoxseg4ei16.c index 6e82d6367..73326df0b 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg4ei16.c +++ b/auto-generated/overloaded-api-testing/vsoxseg4ei16.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg4ei16_v_f16mf4x4(float16_t *rs1, vuint16mf4_t vs2, +void test_vsoxseg4ei16_v_f16mf4x4(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16mf2x4(float16_t *rs1, vuint16mf2_t vs2, +void test_vsoxseg4ei16_v_f16mf2x4(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16m1x4(float16_t *rs1, vuint16m1_t vs2, +void test_vsoxseg4ei16_v_f16m1x4(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16m2x4(float16_t *rs1, vuint16m2_t vs2, +void test_vsoxseg4ei16_v_f16m2x4(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16(rs1, vs2, vs3, vl); } @@ -190,25 +190,24 @@ void test_vsoxseg4ei16_v_u64m2x4(uint64_t *rs1, vuint16mf2_t vs2, return __riscv_vsoxseg4ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg4ei16_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg4ei16_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x4_t vs3, - size_t vl) { +void test_vsoxseg4ei16_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei16_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, +void test_vsoxseg4ei16_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg4ei32.c b/auto-generated/overloaded-api-testing/vsoxseg4ei32.c index 9fe032a85..f1804a9c7 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg4ei32.c +++ b/auto-generated/overloaded-api-testing/vsoxseg4ei32.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg4ei32_v_f16mf4x4(float16_t *rs1, vuint32mf2_t vs2, +void test_vsoxseg4ei32_v_f16mf4x4(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16mf2x4(float16_t *rs1, vuint32m1_t vs2, +void test_vsoxseg4ei32_v_f16mf2x4(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16m1x4(float16_t *rs1, vuint32m2_t vs2, +void test_vsoxseg4ei32_v_f16m1x4(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16m2x4(float16_t *rs1, vuint32m4_t vs2, +void test_vsoxseg4ei32_v_f16m2x4(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32(rs1, vs2, vs3, vl); } @@ -190,25 +190,24 @@ void test_vsoxseg4ei32_v_u64m2x4(uint64_t *rs1, vuint32m1_t vs2, return __riscv_vsoxseg4ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg4ei32_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg4ei32_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x4_t vs3, - size_t vl) { +void test_vsoxseg4ei32_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei32_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, +void test_vsoxseg4ei32_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg4ei64.c b/auto-generated/overloaded-api-testing/vsoxseg4ei64.c index 834f5887f..2f6a9a123 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg4ei64.c +++ b/auto-generated/overloaded-api-testing/vsoxseg4ei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg4ei64_v_f16mf4x4(float16_t *rs1, vuint64m1_t vs2, +void test_vsoxseg4ei64_v_f16mf4x4(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16mf2x4(float16_t *rs1, vuint64m2_t vs2, +void test_vsoxseg4ei64_v_f16mf2x4(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16m1x4(float16_t *rs1, vuint64m4_t vs2, +void test_vsoxseg4ei64_v_f16m1x4(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16m2x4(float16_t *rs1, vuint64m8_t vs2, +void test_vsoxseg4ei64_v_f16m2x4(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64(rs1, vs2, vs3, vl); } @@ -180,25 +180,24 @@ void test_vsoxseg4ei64_v_u64m2x4(uint64_t *rs1, vuint64m2_t vs2, return __riscv_vsoxseg4ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg4ei64_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg4ei64_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x4_t vs3, - size_t vl) { +void test_vsoxseg4ei64_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei64_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, +void test_vsoxseg4ei64_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg4ei8.c b/auto-generated/overloaded-api-testing/vsoxseg4ei8.c index 8524738d6..332dbd01e 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg4ei8.c +++ b/auto-generated/overloaded-api-testing/vsoxseg4ei8.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg4ei8_v_f16mf4x4(float16_t *rs1, vuint8mf8_t vs2, +void test_vsoxseg4ei8_v_f16mf4x4(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16mf2x4(float16_t *rs1, vuint8mf4_t vs2, +void test_vsoxseg4ei8_v_f16mf2x4(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16m1x4(float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg4ei8_v_f16m1x4(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16m2x4(float16_t *rs1, vuint8m1_t vs2, +void test_vsoxseg4ei8_v_f16m2x4(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8(rs1, vs2, vs3, vl); } @@ -190,24 +190,22 @@ void test_vsoxseg4ei8_v_u64m2x4(uint64_t *rs1, vuint8mf4_t vs2, return __riscv_vsoxseg4ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x4_t vs3, - size_t vl) { +void test_vsoxseg4ei8_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x4_t vs3, - size_t vl) { +void test_vsoxseg4ei8_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg4ei8_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg4ei8_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, +void test_vsoxseg4ei8_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsoxseg4ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg5ei16.c b/auto-generated/overloaded-api-testing/vsoxseg5ei16.c index 05f525176..31c3a65ea 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg5ei16.c +++ b/auto-generated/overloaded-api-testing/vsoxseg5ei16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg5ei16_v_f16mf4x5(float16_t *rs1, vuint16mf4_t vs2, +void test_vsoxseg5ei16_v_f16mf4x5(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16mf2x5(float16_t *rs1, vuint16mf2_t vs2, +void test_vsoxseg5ei16_v_f16mf2x5(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16m1x5(float16_t *rs1, vuint16m1_t vs2, +void test_vsoxseg5ei16_v_f16m1x5(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg5ei16_v_u64m1x5(uint64_t *rs1, vuint16mf4_t vs2, return __riscv_vsoxseg5ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg5ei16_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg5ei16_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei16_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x5_t vs3, - size_t vl) { +void test_vsoxseg5ei16_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg5ei32.c b/auto-generated/overloaded-api-testing/vsoxseg5ei32.c index 5e26527ce..27ff8fc46 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg5ei32.c +++ b/auto-generated/overloaded-api-testing/vsoxseg5ei32.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg5ei32_v_f16mf4x5(float16_t *rs1, vuint32mf2_t vs2, +void test_vsoxseg5ei32_v_f16mf4x5(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16mf2x5(float16_t *rs1, vuint32m1_t vs2, +void test_vsoxseg5ei32_v_f16mf2x5(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16m1x5(float16_t *rs1, vuint32m2_t vs2, +void test_vsoxseg5ei32_v_f16m1x5(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg5ei32_v_u64m1x5(uint64_t *rs1, vuint32mf2_t vs2, return __riscv_vsoxseg5ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg5ei32_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg5ei32_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei32_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x5_t vs3, - size_t vl) { +void test_vsoxseg5ei32_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg5ei64.c b/auto-generated/overloaded-api-testing/vsoxseg5ei64.c index efb0bc4ed..bc80d61d3 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg5ei64.c +++ b/auto-generated/overloaded-api-testing/vsoxseg5ei64.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg5ei64_v_f16mf4x5(float16_t *rs1, vuint64m1_t vs2, +void test_vsoxseg5ei64_v_f16mf4x5(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16mf2x5(float16_t *rs1, vuint64m2_t vs2, +void test_vsoxseg5ei64_v_f16mf2x5(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16m1x5(float16_t *rs1, vuint64m4_t vs2, +void test_vsoxseg5ei64_v_f16m1x5(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg5ei64_v_u64m1x5(uint64_t *rs1, vuint64m1_t vs2, return __riscv_vsoxseg5ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg5ei64_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg5ei64_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei64_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x5_t vs3, - size_t vl) { +void test_vsoxseg5ei64_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg5ei8.c b/auto-generated/overloaded-api-testing/vsoxseg5ei8.c index e881476ac..6f00c25b4 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg5ei8.c +++ b/auto-generated/overloaded-api-testing/vsoxseg5ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg5ei8_v_f16mf4x5(float16_t *rs1, vuint8mf8_t vs2, +void test_vsoxseg5ei8_v_f16mf4x5(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16mf2x5(float16_t *rs1, vuint8mf4_t vs2, +void test_vsoxseg5ei8_v_f16mf2x5(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16m1x5(float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg5ei8_v_f16m1x5(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8(rs1, vs2, vs3, vl); } @@ -135,19 +135,17 @@ void test_vsoxseg5ei8_v_u64m1x5(uint64_t *rs1, vuint8mf8_t vs2, return __riscv_vsoxseg5ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x5_t vs3, - size_t vl) { +void test_vsoxseg5ei8_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x5_t vs3, - size_t vl) { +void test_vsoxseg5ei8_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg5ei8_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg5ei8_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsoxseg5ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg6ei16.c b/auto-generated/overloaded-api-testing/vsoxseg6ei16.c index 897e22854..0a886b101 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg6ei16.c +++ b/auto-generated/overloaded-api-testing/vsoxseg6ei16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg6ei16_v_f16mf4x6(float16_t *rs1, vuint16mf4_t vs2, +void test_vsoxseg6ei16_v_f16mf4x6(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16mf2x6(float16_t *rs1, vuint16mf2_t vs2, +void test_vsoxseg6ei16_v_f16mf2x6(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16m1x6(float16_t *rs1, vuint16m1_t vs2, +void test_vsoxseg6ei16_v_f16m1x6(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg6ei16_v_u64m1x6(uint64_t *rs1, vuint16mf4_t vs2, return __riscv_vsoxseg6ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg6ei16_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg6ei16_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei16_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x6_t vs3, - size_t vl) { +void test_vsoxseg6ei16_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg6ei32.c b/auto-generated/overloaded-api-testing/vsoxseg6ei32.c index 9437d4304..e2459b2bc 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg6ei32.c +++ b/auto-generated/overloaded-api-testing/vsoxseg6ei32.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg6ei32_v_f16mf4x6(float16_t *rs1, vuint32mf2_t vs2, +void test_vsoxseg6ei32_v_f16mf4x6(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16mf2x6(float16_t *rs1, vuint32m1_t vs2, +void test_vsoxseg6ei32_v_f16mf2x6(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16m1x6(float16_t *rs1, vuint32m2_t vs2, +void test_vsoxseg6ei32_v_f16m1x6(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg6ei32_v_u64m1x6(uint64_t *rs1, vuint32mf2_t vs2, return __riscv_vsoxseg6ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg6ei32_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg6ei32_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei32_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x6_t vs3, - size_t vl) { +void test_vsoxseg6ei32_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg6ei64.c b/auto-generated/overloaded-api-testing/vsoxseg6ei64.c index 0bb961d8a..7e3654ed8 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg6ei64.c +++ b/auto-generated/overloaded-api-testing/vsoxseg6ei64.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg6ei64_v_f16mf4x6(float16_t *rs1, vuint64m1_t vs2, +void test_vsoxseg6ei64_v_f16mf4x6(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16mf2x6(float16_t *rs1, vuint64m2_t vs2, +void test_vsoxseg6ei64_v_f16mf2x6(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16m1x6(float16_t *rs1, vuint64m4_t vs2, +void test_vsoxseg6ei64_v_f16m1x6(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg6ei64_v_u64m1x6(uint64_t *rs1, vuint64m1_t vs2, return __riscv_vsoxseg6ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg6ei64_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg6ei64_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei64_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x6_t vs3, - size_t vl) { +void test_vsoxseg6ei64_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg6ei8.c b/auto-generated/overloaded-api-testing/vsoxseg6ei8.c index 1e34590dd..64825ceb1 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg6ei8.c +++ b/auto-generated/overloaded-api-testing/vsoxseg6ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg6ei8_v_f16mf4x6(float16_t *rs1, vuint8mf8_t vs2, +void test_vsoxseg6ei8_v_f16mf4x6(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16mf2x6(float16_t *rs1, vuint8mf4_t vs2, +void test_vsoxseg6ei8_v_f16mf2x6(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16m1x6(float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg6ei8_v_f16m1x6(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8(rs1, vs2, vs3, vl); } @@ -135,19 +135,17 @@ void test_vsoxseg6ei8_v_u64m1x6(uint64_t *rs1, vuint8mf8_t vs2, return __riscv_vsoxseg6ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x6_t vs3, - size_t vl) { +void test_vsoxseg6ei8_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x6_t vs3, - size_t vl) { +void test_vsoxseg6ei8_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg6ei8_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg6ei8_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsoxseg6ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg7ei16.c b/auto-generated/overloaded-api-testing/vsoxseg7ei16.c index dcfd51376..9fefec323 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg7ei16.c +++ b/auto-generated/overloaded-api-testing/vsoxseg7ei16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg7ei16_v_f16mf4x7(float16_t *rs1, vuint16mf4_t vs2, +void test_vsoxseg7ei16_v_f16mf4x7(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16mf2x7(float16_t *rs1, vuint16mf2_t vs2, +void test_vsoxseg7ei16_v_f16mf2x7(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16m1x7(float16_t *rs1, vuint16m1_t vs2, +void test_vsoxseg7ei16_v_f16m1x7(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg7ei16_v_u64m1x7(uint64_t *rs1, vuint16mf4_t vs2, return __riscv_vsoxseg7ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg7ei16_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg7ei16_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei16_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x7_t vs3, - size_t vl) { +void test_vsoxseg7ei16_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg7ei32.c b/auto-generated/overloaded-api-testing/vsoxseg7ei32.c index dcdcf5026..b81e54e10 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg7ei32.c +++ b/auto-generated/overloaded-api-testing/vsoxseg7ei32.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg7ei32_v_f16mf4x7(float16_t *rs1, vuint32mf2_t vs2, +void test_vsoxseg7ei32_v_f16mf4x7(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16mf2x7(float16_t *rs1, vuint32m1_t vs2, +void test_vsoxseg7ei32_v_f16mf2x7(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16m1x7(float16_t *rs1, vuint32m2_t vs2, +void test_vsoxseg7ei32_v_f16m1x7(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg7ei32_v_u64m1x7(uint64_t *rs1, vuint32mf2_t vs2, return __riscv_vsoxseg7ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg7ei32_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg7ei32_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei32_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x7_t vs3, - size_t vl) { +void test_vsoxseg7ei32_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg7ei64.c b/auto-generated/overloaded-api-testing/vsoxseg7ei64.c index 26e0357fa..1b0f976a7 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg7ei64.c +++ b/auto-generated/overloaded-api-testing/vsoxseg7ei64.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg7ei64_v_f16mf4x7(float16_t *rs1, vuint64m1_t vs2, +void test_vsoxseg7ei64_v_f16mf4x7(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16mf2x7(float16_t *rs1, vuint64m2_t vs2, +void test_vsoxseg7ei64_v_f16mf2x7(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16m1x7(float16_t *rs1, vuint64m4_t vs2, +void test_vsoxseg7ei64_v_f16m1x7(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg7ei64_v_u64m1x7(uint64_t *rs1, vuint64m1_t vs2, return __riscv_vsoxseg7ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg7ei64_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg7ei64_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei64_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x7_t vs3, - size_t vl) { +void test_vsoxseg7ei64_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg7ei8.c b/auto-generated/overloaded-api-testing/vsoxseg7ei8.c index 085a95059..d1dd1f657 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg7ei8.c +++ b/auto-generated/overloaded-api-testing/vsoxseg7ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg7ei8_v_f16mf4x7(float16_t *rs1, vuint8mf8_t vs2, +void test_vsoxseg7ei8_v_f16mf4x7(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16mf2x7(float16_t *rs1, vuint8mf4_t vs2, +void test_vsoxseg7ei8_v_f16mf2x7(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16m1x7(float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg7ei8_v_f16m1x7(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8(rs1, vs2, vs3, vl); } @@ -135,19 +135,17 @@ void test_vsoxseg7ei8_v_u64m1x7(uint64_t *rs1, vuint8mf8_t vs2, return __riscv_vsoxseg7ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x7_t vs3, - size_t vl) { +void test_vsoxseg7ei8_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x7_t vs3, - size_t vl) { +void test_vsoxseg7ei8_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg7ei8_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg7ei8_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsoxseg7ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg8ei16.c b/auto-generated/overloaded-api-testing/vsoxseg8ei16.c index f2ce52474..8517ae54c 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg8ei16.c +++ b/auto-generated/overloaded-api-testing/vsoxseg8ei16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg8ei16_v_f16mf4x8(float16_t *rs1, vuint16mf4_t vs2, +void test_vsoxseg8ei16_v_f16mf4x8(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16mf2x8(float16_t *rs1, vuint16mf2_t vs2, +void test_vsoxseg8ei16_v_f16mf2x8(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16m1x8(float16_t *rs1, vuint16m1_t vs2, +void test_vsoxseg8ei16_v_f16m1x8(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg8ei16_v_u64m1x8(uint64_t *rs1, vuint16mf4_t vs2, return __riscv_vsoxseg8ei16(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg8ei16_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg8ei16_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei16_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x8_t vs3, - size_t vl) { +void test_vsoxseg8ei16_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg8ei32.c b/auto-generated/overloaded-api-testing/vsoxseg8ei32.c index b572afc99..9c1301822 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg8ei32.c +++ b/auto-generated/overloaded-api-testing/vsoxseg8ei32.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg8ei32_v_f16mf4x8(float16_t *rs1, vuint32mf2_t vs2, +void test_vsoxseg8ei32_v_f16mf4x8(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16mf2x8(float16_t *rs1, vuint32m1_t vs2, +void test_vsoxseg8ei32_v_f16mf2x8(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16m1x8(float16_t *rs1, vuint32m2_t vs2, +void test_vsoxseg8ei32_v_f16m1x8(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg8ei32_v_u64m1x8(uint64_t *rs1, vuint32mf2_t vs2, return __riscv_vsoxseg8ei32(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg8ei32_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg8ei32_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei32_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x8_t vs3, - size_t vl) { +void test_vsoxseg8ei32_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg8ei64.c b/auto-generated/overloaded-api-testing/vsoxseg8ei64.c index 8530d40e1..9fd13f2a9 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg8ei64.c +++ b/auto-generated/overloaded-api-testing/vsoxseg8ei64.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg8ei64_v_f16mf4x8(float16_t *rs1, vuint64m1_t vs2, +void test_vsoxseg8ei64_v_f16mf4x8(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16mf2x8(float16_t *rs1, vuint64m2_t vs2, +void test_vsoxseg8ei64_v_f16mf2x8(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16m1x8(float16_t *rs1, vuint64m4_t vs2, +void test_vsoxseg8ei64_v_f16m1x8(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsoxseg8ei64_v_u64m1x8(uint64_t *rs1, vuint64m1_t vs2, return __riscv_vsoxseg8ei64(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, +void test_vsoxseg8ei64_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, +void test_vsoxseg8ei64_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei64_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x8_t vs3, - size_t vl) { +void test_vsoxseg8ei64_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsoxseg8ei8.c b/auto-generated/overloaded-api-testing/vsoxseg8ei8.c index 6a647a961..bc3860add 100644 --- a/auto-generated/overloaded-api-testing/vsoxseg8ei8.c +++ b/auto-generated/overloaded-api-testing/vsoxseg8ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsoxseg8ei8_v_f16mf4x8(float16_t *rs1, vuint8mf8_t vs2, +void test_vsoxseg8ei8_v_f16mf4x8(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16mf2x8(float16_t *rs1, vuint8mf4_t vs2, +void test_vsoxseg8ei8_v_f16mf2x8(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16m1x8(float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg8ei8_v_f16m1x8(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8(rs1, vs2, vs3, vl); } @@ -135,19 +135,17 @@ void test_vsoxseg8ei8_v_u64m1x8(uint64_t *rs1, vuint8mf8_t vs2, return __riscv_vsoxseg8ei8(rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x8_t vs3, - size_t vl) { +void test_vsoxseg8ei8_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x8_t vs3, - size_t vl) { +void test_vsoxseg8ei8_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8(vm, rs1, vs2, vs3, vl); } -void test_vsoxseg8ei8_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsoxseg8ei8_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsoxseg8ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsse16.c b/auto-generated/overloaded-api-testing/vsse16.c index 5430230c9..993f70be4 100644 --- a/auto-generated/overloaded-api-testing/vsse16.c +++ b/auto-generated/overloaded-api-testing/vsse16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsse16_v_f16mf4(float16_t *rs1, ptrdiff_t rs2, vfloat16mf4_t vs3, +void test_vsse16_v_f16mf4(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsse16(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16mf2(float16_t *rs1, ptrdiff_t rs2, vfloat16mf2_t vs3, +void test_vsse16_v_f16mf2(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsse16(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m1(float16_t *rs1, ptrdiff_t rs2, vfloat16m1_t vs3, +void test_vsse16_v_f16m1(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsse16(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m2(float16_t *rs1, ptrdiff_t rs2, vfloat16m2_t vs3, +void test_vsse16_v_f16m2(_Float16 *rs1, ptrdiff_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsse16(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m4(float16_t *rs1, ptrdiff_t rs2, vfloat16m4_t vs3, +void test_vsse16_v_f16m4(_Float16 *rs1, ptrdiff_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsse16(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m8(float16_t *rs1, ptrdiff_t rs2, vfloat16m8_t vs3, +void test_vsse16_v_f16m8(_Float16 *rs1, ptrdiff_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsse16(rs1, rs2, vs3, vl); } @@ -95,32 +95,32 @@ void test_vsse16_v_u16m8(uint16_t *rs1, ptrdiff_t rs2, vuint16m8_t vs3, return __riscv_vsse16(rs1, rs2, vs3, vl); } -void test_vsse16_v_f16mf4_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vsse16_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsse16(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16mf2_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vsse16_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsse16(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m1_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vsse16_v_f16m1_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsse16(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m2_m(vbool8_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vsse16_v_f16m2_m(vbool8_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsse16(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m4_m(vbool4_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vsse16_v_f16m4_m(vbool4_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsse16(vm, rs1, rs2, vs3, vl); } -void test_vsse16_v_f16m8_m(vbool2_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vsse16_v_f16m8_m(vbool2_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsse16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsseg2e16.c b/auto-generated/overloaded-api-testing/vsseg2e16.c index bf329d9db..f8a8ea90e 100644 --- a/auto-generated/overloaded-api-testing/vsseg2e16.c +++ b/auto-generated/overloaded-api-testing/vsseg2e16.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg2e16_v_f16mf4x2(float16_t *rs1, vfloat16mf4x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16mf4x2(_Float16 *rs1, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsseg2e16(rs1, vs3, vl); } -void test_vsseg2e16_v_f16mf2x2(float16_t *rs1, vfloat16mf2x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16mf2x2(_Float16 *rs1, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsseg2e16(rs1, vs3, vl); } -void test_vsseg2e16_v_f16m1x2(float16_t *rs1, vfloat16m1x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m1x2(_Float16 *rs1, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsseg2e16(rs1, vs3, vl); } -void test_vsseg2e16_v_f16m2x2(float16_t *rs1, vfloat16m2x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m2x2(_Float16 *rs1, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsseg2e16(rs1, vs3, vl); } -void test_vsseg2e16_v_f16m4x2(float16_t *rs1, vfloat16m4x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m4x2(_Float16 *rs1, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsseg2e16(rs1, vs3, vl); } @@ -65,27 +65,27 @@ void test_vsseg2e16_v_u16m4x2(uint16_t *rs1, vuint16m4x2_t vs3, size_t vl) { return __riscv_vsseg2e16(rs1, vs3, vl); } -void test_vsseg2e16_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, +void test_vsseg2e16_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsseg2e16(vm, rs1, vs3, vl); } -void test_vsseg2e16_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, +void test_vsseg2e16_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsseg2e16(vm, rs1, vs3, vl); } -void test_vsseg2e16_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, - vfloat16m1x2_t vs3, size_t vl) { +void test_vsseg2e16_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x2_t vs3, + size_t vl) { return __riscv_vsseg2e16(vm, rs1, vs3, vl); } -void test_vsseg2e16_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vfloat16m2x2_t vs3, +void test_vsseg2e16_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsseg2e16(vm, rs1, vs3, vl); } -void test_vsseg2e16_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vfloat16m4x2_t vs3, +void test_vsseg2e16_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsseg2e16(vm, rs1, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsseg3e16.c b/auto-generated/overloaded-api-testing/vsseg3e16.c index d3c11e5fd..96dd73a69 100644 --- a/auto-generated/overloaded-api-testing/vsseg3e16.c +++ b/auto-generated/overloaded-api-testing/vsseg3e16.c @@ -5,19 +5,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg3e16_v_f16mf4x3(float16_t *rs1, vfloat16mf4x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16mf4x3(_Float16 *rs1, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsseg3e16(rs1, vs3, vl); } -void test_vsseg3e16_v_f16mf2x3(float16_t *rs1, vfloat16mf2x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16mf2x3(_Float16 *rs1, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsseg3e16(rs1, vs3, vl); } -void test_vsseg3e16_v_f16m1x3(float16_t *rs1, vfloat16m1x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16m1x3(_Float16 *rs1, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsseg3e16(rs1, vs3, vl); } -void test_vsseg3e16_v_f16m2x3(float16_t *rs1, vfloat16m2x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16m2x3(_Float16 *rs1, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsseg3e16(rs1, vs3, vl); } @@ -53,22 +53,22 @@ void test_vsseg3e16_v_u16m2x3(uint16_t *rs1, vuint16m2x3_t vs3, size_t vl) { return __riscv_vsseg3e16(rs1, vs3, vl); } -void test_vsseg3e16_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, +void test_vsseg3e16_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsseg3e16(vm, rs1, vs3, vl); } -void test_vsseg3e16_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, +void test_vsseg3e16_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsseg3e16(vm, rs1, vs3, vl); } -void test_vsseg3e16_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, - vfloat16m1x3_t vs3, size_t vl) { +void test_vsseg3e16_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x3_t vs3, + size_t vl) { return __riscv_vsseg3e16(vm, rs1, vs3, vl); } -void test_vsseg3e16_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vfloat16m2x3_t vs3, +void test_vsseg3e16_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsseg3e16(vm, rs1, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsseg4e16.c b/auto-generated/overloaded-api-testing/vsseg4e16.c index f8c2aae91..69ef8fbec 100644 --- a/auto-generated/overloaded-api-testing/vsseg4e16.c +++ b/auto-generated/overloaded-api-testing/vsseg4e16.c @@ -5,19 +5,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg4e16_v_f16mf4x4(float16_t *rs1, vfloat16mf4x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16mf4x4(_Float16 *rs1, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsseg4e16(rs1, vs3, vl); } -void test_vsseg4e16_v_f16mf2x4(float16_t *rs1, vfloat16mf2x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16mf2x4(_Float16 *rs1, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsseg4e16(rs1, vs3, vl); } -void test_vsseg4e16_v_f16m1x4(float16_t *rs1, vfloat16m1x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16m1x4(_Float16 *rs1, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsseg4e16(rs1, vs3, vl); } -void test_vsseg4e16_v_f16m2x4(float16_t *rs1, vfloat16m2x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16m2x4(_Float16 *rs1, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsseg4e16(rs1, vs3, vl); } @@ -53,22 +53,22 @@ void test_vsseg4e16_v_u16m2x4(uint16_t *rs1, vuint16m2x4_t vs3, size_t vl) { return __riscv_vsseg4e16(rs1, vs3, vl); } -void test_vsseg4e16_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, +void test_vsseg4e16_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsseg4e16(vm, rs1, vs3, vl); } -void test_vsseg4e16_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, +void test_vsseg4e16_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsseg4e16(vm, rs1, vs3, vl); } -void test_vsseg4e16_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, - vfloat16m1x4_t vs3, size_t vl) { +void test_vsseg4e16_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x4_t vs3, + size_t vl) { return __riscv_vsseg4e16(vm, rs1, vs3, vl); } -void test_vsseg4e16_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vfloat16m2x4_t vs3, +void test_vsseg4e16_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsseg4e16(vm, rs1, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsseg5e16.c b/auto-generated/overloaded-api-testing/vsseg5e16.c index bb476f4c0..fabaae73d 100644 --- a/auto-generated/overloaded-api-testing/vsseg5e16.c +++ b/auto-generated/overloaded-api-testing/vsseg5e16.c @@ -5,15 +5,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg5e16_v_f16mf4x5(float16_t *rs1, vfloat16mf4x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16mf4x5(_Float16 *rs1, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsseg5e16(rs1, vs3, vl); } -void test_vsseg5e16_v_f16mf2x5(float16_t *rs1, vfloat16mf2x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16mf2x5(_Float16 *rs1, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsseg5e16(rs1, vs3, vl); } -void test_vsseg5e16_v_f16m1x5(float16_t *rs1, vfloat16m1x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16m1x5(_Float16 *rs1, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsseg5e16(rs1, vs3, vl); } @@ -41,18 +41,18 @@ void test_vsseg5e16_v_u16m1x5(uint16_t *rs1, vuint16m1x5_t vs3, size_t vl) { return __riscv_vsseg5e16(rs1, vs3, vl); } -void test_vsseg5e16_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, +void test_vsseg5e16_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsseg5e16(vm, rs1, vs3, vl); } -void test_vsseg5e16_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, +void test_vsseg5e16_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsseg5e16(vm, rs1, vs3, vl); } -void test_vsseg5e16_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, - vfloat16m1x5_t vs3, size_t vl) { +void test_vsseg5e16_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x5_t vs3, + size_t vl) { return __riscv_vsseg5e16(vm, rs1, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsseg6e16.c b/auto-generated/overloaded-api-testing/vsseg6e16.c index 4a4d75045..7a1962633 100644 --- a/auto-generated/overloaded-api-testing/vsseg6e16.c +++ b/auto-generated/overloaded-api-testing/vsseg6e16.c @@ -5,15 +5,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg6e16_v_f16mf4x6(float16_t *rs1, vfloat16mf4x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16mf4x6(_Float16 *rs1, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsseg6e16(rs1, vs3, vl); } -void test_vsseg6e16_v_f16mf2x6(float16_t *rs1, vfloat16mf2x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16mf2x6(_Float16 *rs1, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsseg6e16(rs1, vs3, vl); } -void test_vsseg6e16_v_f16m1x6(float16_t *rs1, vfloat16m1x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16m1x6(_Float16 *rs1, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsseg6e16(rs1, vs3, vl); } @@ -41,18 +41,18 @@ void test_vsseg6e16_v_u16m1x6(uint16_t *rs1, vuint16m1x6_t vs3, size_t vl) { return __riscv_vsseg6e16(rs1, vs3, vl); } -void test_vsseg6e16_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, +void test_vsseg6e16_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsseg6e16(vm, rs1, vs3, vl); } -void test_vsseg6e16_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, +void test_vsseg6e16_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsseg6e16(vm, rs1, vs3, vl); } -void test_vsseg6e16_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, - vfloat16m1x6_t vs3, size_t vl) { +void test_vsseg6e16_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x6_t vs3, + size_t vl) { return __riscv_vsseg6e16(vm, rs1, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsseg7e16.c b/auto-generated/overloaded-api-testing/vsseg7e16.c index b39d4aaed..49f9e5bbf 100644 --- a/auto-generated/overloaded-api-testing/vsseg7e16.c +++ b/auto-generated/overloaded-api-testing/vsseg7e16.c @@ -5,15 +5,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg7e16_v_f16mf4x7(float16_t *rs1, vfloat16mf4x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16mf4x7(_Float16 *rs1, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsseg7e16(rs1, vs3, vl); } -void test_vsseg7e16_v_f16mf2x7(float16_t *rs1, vfloat16mf2x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16mf2x7(_Float16 *rs1, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsseg7e16(rs1, vs3, vl); } -void test_vsseg7e16_v_f16m1x7(float16_t *rs1, vfloat16m1x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16m1x7(_Float16 *rs1, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsseg7e16(rs1, vs3, vl); } @@ -41,18 +41,18 @@ void test_vsseg7e16_v_u16m1x7(uint16_t *rs1, vuint16m1x7_t vs3, size_t vl) { return __riscv_vsseg7e16(rs1, vs3, vl); } -void test_vsseg7e16_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, +void test_vsseg7e16_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsseg7e16(vm, rs1, vs3, vl); } -void test_vsseg7e16_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, +void test_vsseg7e16_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsseg7e16(vm, rs1, vs3, vl); } -void test_vsseg7e16_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, - vfloat16m1x7_t vs3, size_t vl) { +void test_vsseg7e16_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x7_t vs3, + size_t vl) { return __riscv_vsseg7e16(vm, rs1, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsseg8e16.c b/auto-generated/overloaded-api-testing/vsseg8e16.c index 9a3fb938a..ea86d9d59 100644 --- a/auto-generated/overloaded-api-testing/vsseg8e16.c +++ b/auto-generated/overloaded-api-testing/vsseg8e16.c @@ -5,15 +5,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsseg8e16_v_f16mf4x8(float16_t *rs1, vfloat16mf4x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16mf4x8(_Float16 *rs1, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsseg8e16(rs1, vs3, vl); } -void test_vsseg8e16_v_f16mf2x8(float16_t *rs1, vfloat16mf2x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16mf2x8(_Float16 *rs1, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsseg8e16(rs1, vs3, vl); } -void test_vsseg8e16_v_f16m1x8(float16_t *rs1, vfloat16m1x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16m1x8(_Float16 *rs1, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsseg8e16(rs1, vs3, vl); } @@ -41,18 +41,18 @@ void test_vsseg8e16_v_u16m1x8(uint16_t *rs1, vuint16m1x8_t vs3, size_t vl) { return __riscv_vsseg8e16(rs1, vs3, vl); } -void test_vsseg8e16_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, +void test_vsseg8e16_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsseg8e16(vm, rs1, vs3, vl); } -void test_vsseg8e16_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, +void test_vsseg8e16_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsseg8e16(vm, rs1, vs3, vl); } -void test_vsseg8e16_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, - vfloat16m1x8_t vs3, size_t vl) { +void test_vsseg8e16_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vfloat16m1x8_t vs3, + size_t vl) { return __riscv_vsseg8e16(vm, rs1, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vssseg2e16.c b/auto-generated/overloaded-api-testing/vssseg2e16.c index b3da5c5c4..dd87f1b18 100644 --- a/auto-generated/overloaded-api-testing/vssseg2e16.c +++ b/auto-generated/overloaded-api-testing/vssseg2e16.c @@ -5,28 +5,28 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg2e16_v_f16mf4x2(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg2e16_v_f16mf4x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vssseg2e16(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16mf2x2(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg2e16_v_f16mf2x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vssseg2e16(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m1x2(float16_t *rs1, ptrdiff_t rs2, - vfloat16m1x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m1x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x2_t vs3, + size_t vl) { return __riscv_vssseg2e16(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m2x2(float16_t *rs1, ptrdiff_t rs2, - vfloat16m2x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m2x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16m2x2_t vs3, + size_t vl) { return __riscv_vssseg2e16(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m4x2(float16_t *rs1, ptrdiff_t rs2, - vfloat16m4x2_t vs3, size_t vl) { +void test_vssseg2e16_v_f16m4x2(_Float16 *rs1, ptrdiff_t rs2, vfloat16m4x2_t vs3, + size_t vl) { return __riscv_vssseg2e16(rs1, rs2, vs3, vl); } @@ -80,27 +80,27 @@ void test_vssseg2e16_v_u16m4x2(uint16_t *rs1, ptrdiff_t rs2, vuint16m4x2_t vs3, return __riscv_vssseg2e16(rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg2e16_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vssseg2e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg2e16_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vssseg2e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg2e16_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vssseg2e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg2e16_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vssseg2e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg2e16_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg2e16_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vssseg2e16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vssseg3e16.c b/auto-generated/overloaded-api-testing/vssseg3e16.c index 5f709e5cd..02f63b12b 100644 --- a/auto-generated/overloaded-api-testing/vssseg3e16.c +++ b/auto-generated/overloaded-api-testing/vssseg3e16.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg3e16_v_f16mf4x3(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg3e16_v_f16mf4x3(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vssseg3e16(rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16mf2x3(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg3e16_v_f16mf2x3(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vssseg3e16(rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16m1x3(float16_t *rs1, ptrdiff_t rs2, - vfloat16m1x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16m1x3(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x3_t vs3, + size_t vl) { return __riscv_vssseg3e16(rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16m2x3(float16_t *rs1, ptrdiff_t rs2, - vfloat16m2x3_t vs3, size_t vl) { +void test_vssseg3e16_v_f16m2x3(_Float16 *rs1, ptrdiff_t rs2, vfloat16m2x3_t vs3, + size_t vl) { return __riscv_vssseg3e16(rs1, rs2, vs3, vl); } @@ -65,22 +65,22 @@ void test_vssseg3e16_v_u16m2x3(uint16_t *rs1, ptrdiff_t rs2, vuint16m2x3_t vs3, return __riscv_vssseg3e16(rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg3e16_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vssseg3e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg3e16_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vssseg3e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg3e16_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vssseg3e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg3e16_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg3e16_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vssseg3e16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vssseg4e16.c b/auto-generated/overloaded-api-testing/vssseg4e16.c index 6dc88d8cc..e4d57b947 100644 --- a/auto-generated/overloaded-api-testing/vssseg4e16.c +++ b/auto-generated/overloaded-api-testing/vssseg4e16.c @@ -5,23 +5,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg4e16_v_f16mf4x4(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg4e16_v_f16mf4x4(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vssseg4e16(rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16mf2x4(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg4e16_v_f16mf2x4(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vssseg4e16(rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16m1x4(float16_t *rs1, ptrdiff_t rs2, - vfloat16m1x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16m1x4(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x4_t vs3, + size_t vl) { return __riscv_vssseg4e16(rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16m2x4(float16_t *rs1, ptrdiff_t rs2, - vfloat16m2x4_t vs3, size_t vl) { +void test_vssseg4e16_v_f16m2x4(_Float16 *rs1, ptrdiff_t rs2, vfloat16m2x4_t vs3, + size_t vl) { return __riscv_vssseg4e16(rs1, rs2, vs3, vl); } @@ -65,22 +65,22 @@ void test_vssseg4e16_v_u16m2x4(uint16_t *rs1, ptrdiff_t rs2, vuint16m2x4_t vs3, return __riscv_vssseg4e16(rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg4e16_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vssseg4e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg4e16_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vssseg4e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg4e16_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vssseg4e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg4e16_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg4e16_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vssseg4e16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vssseg5e16.c b/auto-generated/overloaded-api-testing/vssseg5e16.c index 0b254ed8d..84f57c7c2 100644 --- a/auto-generated/overloaded-api-testing/vssseg5e16.c +++ b/auto-generated/overloaded-api-testing/vssseg5e16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg5e16_v_f16mf4x5(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg5e16_v_f16mf4x5(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vssseg5e16(rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16mf2x5(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg5e16_v_f16mf2x5(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vssseg5e16(rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16m1x5(float16_t *rs1, ptrdiff_t rs2, - vfloat16m1x5_t vs3, size_t vl) { +void test_vssseg5e16_v_f16m1x5(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x5_t vs3, + size_t vl) { return __riscv_vssseg5e16(rs1, rs2, vs3, vl); } @@ -50,17 +50,17 @@ void test_vssseg5e16_v_u16m1x5(uint16_t *rs1, ptrdiff_t rs2, vuint16m1x5_t vs3, return __riscv_vssseg5e16(rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg5e16_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vssseg5e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg5e16_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vssseg5e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg5e16_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg5e16_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vssseg5e16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vssseg6e16.c b/auto-generated/overloaded-api-testing/vssseg6e16.c index 4f24b2d55..db8f6652b 100644 --- a/auto-generated/overloaded-api-testing/vssseg6e16.c +++ b/auto-generated/overloaded-api-testing/vssseg6e16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg6e16_v_f16mf4x6(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg6e16_v_f16mf4x6(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vssseg6e16(rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16mf2x6(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg6e16_v_f16mf2x6(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vssseg6e16(rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16m1x6(float16_t *rs1, ptrdiff_t rs2, - vfloat16m1x6_t vs3, size_t vl) { +void test_vssseg6e16_v_f16m1x6(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x6_t vs3, + size_t vl) { return __riscv_vssseg6e16(rs1, rs2, vs3, vl); } @@ -50,17 +50,17 @@ void test_vssseg6e16_v_u16m1x6(uint16_t *rs1, ptrdiff_t rs2, vuint16m1x6_t vs3, return __riscv_vssseg6e16(rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg6e16_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vssseg6e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg6e16_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vssseg6e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg6e16_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg6e16_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vssseg6e16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vssseg7e16.c b/auto-generated/overloaded-api-testing/vssseg7e16.c index 9b587ab6d..7747925ea 100644 --- a/auto-generated/overloaded-api-testing/vssseg7e16.c +++ b/auto-generated/overloaded-api-testing/vssseg7e16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg7e16_v_f16mf4x7(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg7e16_v_f16mf4x7(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vssseg7e16(rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16mf2x7(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg7e16_v_f16mf2x7(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vssseg7e16(rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16m1x7(float16_t *rs1, ptrdiff_t rs2, - vfloat16m1x7_t vs3, size_t vl) { +void test_vssseg7e16_v_f16m1x7(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x7_t vs3, + size_t vl) { return __riscv_vssseg7e16(rs1, rs2, vs3, vl); } @@ -50,17 +50,17 @@ void test_vssseg7e16_v_u16m1x7(uint16_t *rs1, ptrdiff_t rs2, vuint16m1x7_t vs3, return __riscv_vssseg7e16(rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg7e16_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vssseg7e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg7e16_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vssseg7e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg7e16_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg7e16_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vssseg7e16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vssseg8e16.c b/auto-generated/overloaded-api-testing/vssseg8e16.c index 4668de8ee..18948f2e9 100644 --- a/auto-generated/overloaded-api-testing/vssseg8e16.c +++ b/auto-generated/overloaded-api-testing/vssseg8e16.c @@ -5,18 +5,18 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vssseg8e16_v_f16mf4x8(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg8e16_v_f16mf4x8(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vssseg8e16(rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16mf2x8(float16_t *rs1, ptrdiff_t rs2, +void test_vssseg8e16_v_f16mf2x8(_Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vssseg8e16(rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16m1x8(float16_t *rs1, ptrdiff_t rs2, - vfloat16m1x8_t vs3, size_t vl) { +void test_vssseg8e16_v_f16m1x8(_Float16 *rs1, ptrdiff_t rs2, vfloat16m1x8_t vs3, + size_t vl) { return __riscv_vssseg8e16(rs1, rs2, vs3, vl); } @@ -50,17 +50,17 @@ void test_vssseg8e16_v_u16m1x8(uint16_t *rs1, ptrdiff_t rs2, vuint16m1x8_t vs3, return __riscv_vssseg8e16(rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg8e16_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vssseg8e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg8e16_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vssseg8e16(vm, rs1, rs2, vs3, vl); } -void test_vssseg8e16_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, ptrdiff_t rs2, +void test_vssseg8e16_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, ptrdiff_t rs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vssseg8e16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxei16.c b/auto-generated/overloaded-api-testing/vsuxei16.c index f7c7779b5..ccbfabf0a 100644 --- a/auto-generated/overloaded-api-testing/vsuxei16.c +++ b/auto-generated/overloaded-api-testing/vsuxei16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxei16_v_f16mf4(float16_t *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, +void test_vsuxei16_v_f16mf4(_Float16 *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei16(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16mf2(float16_t *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, +void test_vsuxei16_v_f16mf2(_Float16 *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei16(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m1(float16_t *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, +void test_vsuxei16_v_f16m1(_Float16 *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei16(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m2(float16_t *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, +void test_vsuxei16_v_f16m2(_Float16 *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei16(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m4(float16_t *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, +void test_vsuxei16_v_f16m4(_Float16 *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei16(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m8(float16_t *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, +void test_vsuxei16_v_f16m8(_Float16 *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsuxei16(rs1, rs2, vs3, vl); } @@ -290,32 +290,32 @@ void test_vsuxei16_v_u64m8(uint64_t *rs1, vuint16m2_t rs2, vuint64m8_t vs3, return __riscv_vsuxei16(rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint16mf4_t rs2, +void test_vsuxei16_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei16(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint16mf2_t rs2, +void test_vsuxei16_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei16(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint16m1_t rs2, +void test_vsuxei16_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei16(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint16m2_t rs2, +void test_vsuxei16_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei16(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint16m4_t rs2, +void test_vsuxei16_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint16m4_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei16(vm, rs1, rs2, vs3, vl); } -void test_vsuxei16_v_f16m8_m(vbool2_t vm, float16_t *rs1, vuint16m8_t rs2, +void test_vsuxei16_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vuint16m8_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsuxei16(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxei32.c b/auto-generated/overloaded-api-testing/vsuxei32.c index 3b539c099..74e1473dc 100644 --- a/auto-generated/overloaded-api-testing/vsuxei32.c +++ b/auto-generated/overloaded-api-testing/vsuxei32.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxei32_v_f16mf4(float16_t *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, +void test_vsuxei32_v_f16mf4(_Float16 *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei32(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16mf2(float16_t *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, +void test_vsuxei32_v_f16mf2(_Float16 *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei32(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m1(float16_t *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, +void test_vsuxei32_v_f16m1(_Float16 *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei32(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m2(float16_t *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, +void test_vsuxei32_v_f16m2(_Float16 *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei32(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m4(float16_t *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, +void test_vsuxei32_v_f16m4(_Float16 *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei32(rs1, rs2, vs3, vl); } @@ -265,27 +265,27 @@ void test_vsuxei32_v_u64m8(uint64_t *rs1, vuint32m4_t rs2, vuint64m8_t vs3, return __riscv_vsuxei32(rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint32mf2_t rs2, +void test_vsuxei32_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei32(vm, rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint32m1_t rs2, +void test_vsuxei32_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei32(vm, rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint32m2_t rs2, +void test_vsuxei32_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei32(vm, rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint32m4_t rs2, +void test_vsuxei32_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei32(vm, rs1, rs2, vs3, vl); } -void test_vsuxei32_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint32m8_t rs2, +void test_vsuxei32_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint32m8_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei32(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxei64.c b/auto-generated/overloaded-api-testing/vsuxei64.c index c1810ea06..20a98bd60 100644 --- a/auto-generated/overloaded-api-testing/vsuxei64.c +++ b/auto-generated/overloaded-api-testing/vsuxei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxei64_v_f16mf4(float16_t *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, +void test_vsuxei64_v_f16mf4(_Float16 *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei64(rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16mf2(float16_t *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, +void test_vsuxei64_v_f16mf2(_Float16 *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei64(rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16m1(float16_t *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, +void test_vsuxei64_v_f16m1(_Float16 *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei64(rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16m2(float16_t *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, +void test_vsuxei64_v_f16m2(_Float16 *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei64(rs1, rs2, vs3, vl); } @@ -225,22 +225,22 @@ void test_vsuxei64_v_u64m8(uint64_t *rs1, vuint64m8_t rs2, vuint64m8_t vs3, return __riscv_vsuxei64(rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint64m1_t rs2, +void test_vsuxei64_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei64(vm, rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint64m2_t rs2, +void test_vsuxei64_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei64(vm, rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint64m4_t rs2, +void test_vsuxei64_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei64(vm, rs1, rs2, vs3, vl); } -void test_vsuxei64_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint64m8_t rs2, +void test_vsuxei64_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei64(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxei8.c b/auto-generated/overloaded-api-testing/vsuxei8.c index 34404425a..5542cfc79 100644 --- a/auto-generated/overloaded-api-testing/vsuxei8.c +++ b/auto-generated/overloaded-api-testing/vsuxei8.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxei8_v_f16mf4(float16_t *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, +void test_vsuxei8_v_f16mf4(_Float16 *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei8(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16mf2(float16_t *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, +void test_vsuxei8_v_f16mf2(_Float16 *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei8(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m1(float16_t *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, +void test_vsuxei8_v_f16m1(_Float16 *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei8(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m2(float16_t *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, +void test_vsuxei8_v_f16m2(_Float16 *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei8(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m4(float16_t *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, +void test_vsuxei8_v_f16m4(_Float16 *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei8(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m8(float16_t *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, +void test_vsuxei8_v_f16m8(_Float16 *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsuxei8(rs1, rs2, vs3, vl); } @@ -300,32 +300,32 @@ void test_vsuxei8_v_u64m8(uint64_t *rs1, vuint8m1_t rs2, vuint64m8_t vs3, return __riscv_vsuxei8(rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16mf4_m(vbool64_t vm, float16_t *rs1, vuint8mf8_t rs2, +void test_vsuxei8_v_f16mf4_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t rs2, vfloat16mf4_t vs3, size_t vl) { return __riscv_vsuxei8(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16mf2_m(vbool32_t vm, float16_t *rs1, vuint8mf4_t rs2, +void test_vsuxei8_v_f16mf2_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t rs2, vfloat16mf2_t vs3, size_t vl) { return __riscv_vsuxei8(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m1_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t rs2, +void test_vsuxei8_v_f16m1_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t rs2, vfloat16m1_t vs3, size_t vl) { return __riscv_vsuxei8(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m2_m(vbool8_t vm, float16_t *rs1, vuint8m1_t rs2, +void test_vsuxei8_v_f16m2_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t rs2, vfloat16m2_t vs3, size_t vl) { return __riscv_vsuxei8(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m4_m(vbool4_t vm, float16_t *rs1, vuint8m2_t rs2, +void test_vsuxei8_v_f16m4_m(vbool4_t vm, _Float16 *rs1, vuint8m2_t rs2, vfloat16m4_t vs3, size_t vl) { return __riscv_vsuxei8(vm, rs1, rs2, vs3, vl); } -void test_vsuxei8_v_f16m8_m(vbool2_t vm, float16_t *rs1, vuint8m4_t rs2, +void test_vsuxei8_v_f16m8_m(vbool2_t vm, _Float16 *rs1, vuint8m4_t rs2, vfloat16m8_t vs3, size_t vl) { return __riscv_vsuxei8(vm, rs1, rs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg2ei16.c b/auto-generated/overloaded-api-testing/vsuxseg2ei16.c index 3286ac63f..ba627a049 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg2ei16.c +++ b/auto-generated/overloaded-api-testing/vsuxseg2ei16.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg2ei16_v_f16mf4x2(float16_t *rs1, vuint16mf4_t vs2, +void test_vsuxseg2ei16_v_f16mf4x2(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16mf2x2(float16_t *rs1, vuint16mf2_t vs2, +void test_vsuxseg2ei16_v_f16mf2x2(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m1x2(float16_t *rs1, vuint16m1_t vs2, +void test_vsuxseg2ei16_v_f16m1x2(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m2x2(float16_t *rs1, vuint16m2_t vs2, +void test_vsuxseg2ei16_v_f16m2x2(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m4x2(float16_t *rs1, vuint16m4_t vs2, +void test_vsuxseg2ei16_v_f16m4x2(_Float16 *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(rs1, vs2, vs3, vl); } @@ -245,30 +245,29 @@ void test_vsuxseg2ei16_v_u64m4x2(uint64_t *rs1, vuint16m1_t vs2, return __riscv_vsuxseg2ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg2ei16_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg2ei16_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x2_t vs3, - size_t vl) { +void test_vsuxseg2ei16_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, +void test_vsuxseg2ei16_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei16_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint16m4_t vs2, +void test_vsuxseg2ei16_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint16m4_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg2ei32.c b/auto-generated/overloaded-api-testing/vsuxseg2ei32.c index 8261ddf89..fc0f20542 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg2ei32.c +++ b/auto-generated/overloaded-api-testing/vsuxseg2ei32.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg2ei32_v_f16mf4x2(float16_t *rs1, vuint32mf2_t vs2, +void test_vsuxseg2ei32_v_f16mf4x2(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16mf2x2(float16_t *rs1, vuint32m1_t vs2, +void test_vsuxseg2ei32_v_f16mf2x2(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m1x2(float16_t *rs1, vuint32m2_t vs2, +void test_vsuxseg2ei32_v_f16m1x2(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m2x2(float16_t *rs1, vuint32m4_t vs2, +void test_vsuxseg2ei32_v_f16m2x2(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m4x2(float16_t *rs1, vuint32m8_t vs2, +void test_vsuxseg2ei32_v_f16m4x2(_Float16 *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(rs1, vs2, vs3, vl); } @@ -235,30 +235,29 @@ void test_vsuxseg2ei32_v_u64m4x2(uint64_t *rs1, vuint32m2_t vs2, return __riscv_vsuxseg2ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg2ei32_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg2ei32_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x2_t vs3, - size_t vl) { +void test_vsuxseg2ei32_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, +void test_vsuxseg2ei32_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei32_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint32m8_t vs2, +void test_vsuxseg2ei32_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint32m8_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg2ei64.c b/auto-generated/overloaded-api-testing/vsuxseg2ei64.c index 74f336480..81fea9969 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg2ei64.c +++ b/auto-generated/overloaded-api-testing/vsuxseg2ei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg2ei64_v_f16mf4x2(float16_t *rs1, vuint64m1_t vs2, +void test_vsuxseg2ei64_v_f16mf4x2(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16mf2x2(float16_t *rs1, vuint64m2_t vs2, +void test_vsuxseg2ei64_v_f16mf2x2(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16m1x2(float16_t *rs1, vuint64m4_t vs2, +void test_vsuxseg2ei64_v_f16m1x2(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16m2x2(float16_t *rs1, vuint64m8_t vs2, +void test_vsuxseg2ei64_v_f16m2x2(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64(rs1, vs2, vs3, vl); } @@ -210,25 +210,24 @@ void test_vsuxseg2ei64_v_u64m4x2(uint64_t *rs1, vuint64m4_t vs2, return __riscv_vsuxseg2ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg2ei64_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg2ei64_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x2_t vs3, - size_t vl) { +void test_vsuxseg2ei64_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei64_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, +void test_vsuxseg2ei64_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg2ei8.c b/auto-generated/overloaded-api-testing/vsuxseg2ei8.c index 892aa2b2d..1b9304811 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg2ei8.c +++ b/auto-generated/overloaded-api-testing/vsuxseg2ei8.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg2ei8_v_f16mf4x2(float16_t *rs1, vuint8mf8_t vs2, +void test_vsuxseg2ei8_v_f16mf4x2(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16mf2x2(float16_t *rs1, vuint8mf4_t vs2, +void test_vsuxseg2ei8_v_f16mf2x2(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m1x2(float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg2ei8_v_f16m1x2(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m2x2(float16_t *rs1, vuint8m1_t vs2, +void test_vsuxseg2ei8_v_f16m2x2(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m4x2(float16_t *rs1, vuint8m2_t vs2, +void test_vsuxseg2ei8_v_f16m4x2(_Float16 *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(rs1, vs2, vs3, vl); } @@ -245,29 +245,27 @@ void test_vsuxseg2ei8_v_u64m4x2(uint64_t *rs1, vuint8mf2_t vs2, return __riscv_vsuxseg2ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16mf4x2_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x2_t vs3, - size_t vl) { +void test_vsuxseg2ei8_v_f16mf4x2_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16mf2x2_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x2_t vs3, - size_t vl) { +void test_vsuxseg2ei8_v_f16mf2x2_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m1x2_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg2ei8_v_f16m1x2_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m2x2_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, +void test_vsuxseg2ei8_v_f16m2x2_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg2ei8_v_f16m4x2_m(vbool4_t vm, float16_t *rs1, vuint8m2_t vs2, +void test_vsuxseg2ei8_v_f16m4x2_m(vbool4_t vm, _Float16 *rs1, vuint8m2_t vs2, vfloat16m4x2_t vs3, size_t vl) { return __riscv_vsuxseg2ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg3ei16.c b/auto-generated/overloaded-api-testing/vsuxseg3ei16.c index 302377b95..1b541d665 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg3ei16.c +++ b/auto-generated/overloaded-api-testing/vsuxseg3ei16.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg3ei16_v_f16mf4x3(float16_t *rs1, vuint16mf4_t vs2, +void test_vsuxseg3ei16_v_f16mf4x3(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16mf2x3(float16_t *rs1, vuint16mf2_t vs2, +void test_vsuxseg3ei16_v_f16mf2x3(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16m1x3(float16_t *rs1, vuint16m1_t vs2, +void test_vsuxseg3ei16_v_f16m1x3(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16m2x3(float16_t *rs1, vuint16m2_t vs2, +void test_vsuxseg3ei16_v_f16m2x3(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16(rs1, vs2, vs3, vl); } @@ -190,25 +190,24 @@ void test_vsuxseg3ei16_v_u64m2x3(uint64_t *rs1, vuint16mf2_t vs2, return __riscv_vsuxseg3ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg3ei16_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg3ei16_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x3_t vs3, - size_t vl) { +void test_vsuxseg3ei16_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei16_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, +void test_vsuxseg3ei16_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg3ei32.c b/auto-generated/overloaded-api-testing/vsuxseg3ei32.c index 705e12135..39ddf1198 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg3ei32.c +++ b/auto-generated/overloaded-api-testing/vsuxseg3ei32.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg3ei32_v_f16mf4x3(float16_t *rs1, vuint32mf2_t vs2, +void test_vsuxseg3ei32_v_f16mf4x3(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16mf2x3(float16_t *rs1, vuint32m1_t vs2, +void test_vsuxseg3ei32_v_f16mf2x3(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16m1x3(float16_t *rs1, vuint32m2_t vs2, +void test_vsuxseg3ei32_v_f16m1x3(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16m2x3(float16_t *rs1, vuint32m4_t vs2, +void test_vsuxseg3ei32_v_f16m2x3(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32(rs1, vs2, vs3, vl); } @@ -190,25 +190,24 @@ void test_vsuxseg3ei32_v_u64m2x3(uint64_t *rs1, vuint32m1_t vs2, return __riscv_vsuxseg3ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg3ei32_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg3ei32_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x3_t vs3, - size_t vl) { +void test_vsuxseg3ei32_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei32_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, +void test_vsuxseg3ei32_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg3ei64.c b/auto-generated/overloaded-api-testing/vsuxseg3ei64.c index 4a835a3b0..3c0a400f5 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg3ei64.c +++ b/auto-generated/overloaded-api-testing/vsuxseg3ei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg3ei64_v_f16mf4x3(float16_t *rs1, vuint64m1_t vs2, +void test_vsuxseg3ei64_v_f16mf4x3(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16mf2x3(float16_t *rs1, vuint64m2_t vs2, +void test_vsuxseg3ei64_v_f16mf2x3(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16m1x3(float16_t *rs1, vuint64m4_t vs2, +void test_vsuxseg3ei64_v_f16m1x3(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16m2x3(float16_t *rs1, vuint64m8_t vs2, +void test_vsuxseg3ei64_v_f16m2x3(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64(rs1, vs2, vs3, vl); } @@ -180,25 +180,24 @@ void test_vsuxseg3ei64_v_u64m2x3(uint64_t *rs1, vuint64m2_t vs2, return __riscv_vsuxseg3ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg3ei64_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg3ei64_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x3_t vs3, - size_t vl) { +void test_vsuxseg3ei64_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei64_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, +void test_vsuxseg3ei64_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg3ei8.c b/auto-generated/overloaded-api-testing/vsuxseg3ei8.c index e5e51517e..c5dd550d0 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg3ei8.c +++ b/auto-generated/overloaded-api-testing/vsuxseg3ei8.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg3ei8_v_f16mf4x3(float16_t *rs1, vuint8mf8_t vs2, +void test_vsuxseg3ei8_v_f16mf4x3(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16mf2x3(float16_t *rs1, vuint8mf4_t vs2, +void test_vsuxseg3ei8_v_f16mf2x3(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16m1x3(float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg3ei8_v_f16m1x3(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16m2x3(float16_t *rs1, vuint8m1_t vs2, +void test_vsuxseg3ei8_v_f16m2x3(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8(rs1, vs2, vs3, vl); } @@ -190,24 +190,22 @@ void test_vsuxseg3ei8_v_u64m2x3(uint64_t *rs1, vuint8mf4_t vs2, return __riscv_vsuxseg3ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16mf4x3_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x3_t vs3, - size_t vl) { +void test_vsuxseg3ei8_v_f16mf4x3_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16mf2x3_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x3_t vs3, - size_t vl) { +void test_vsuxseg3ei8_v_f16mf2x3_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16m1x3_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg3ei8_v_f16m1x3_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg3ei8_v_f16m2x3_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, +void test_vsuxseg3ei8_v_f16m2x3_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x3_t vs3, size_t vl) { return __riscv_vsuxseg3ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg4ei16.c b/auto-generated/overloaded-api-testing/vsuxseg4ei16.c index 89e504966..6f432f6b3 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg4ei16.c +++ b/auto-generated/overloaded-api-testing/vsuxseg4ei16.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg4ei16_v_f16mf4x4(float16_t *rs1, vuint16mf4_t vs2, +void test_vsuxseg4ei16_v_f16mf4x4(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16mf2x4(float16_t *rs1, vuint16mf2_t vs2, +void test_vsuxseg4ei16_v_f16mf2x4(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16m1x4(float16_t *rs1, vuint16m1_t vs2, +void test_vsuxseg4ei16_v_f16m1x4(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16m2x4(float16_t *rs1, vuint16m2_t vs2, +void test_vsuxseg4ei16_v_f16m2x4(_Float16 *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16(rs1, vs2, vs3, vl); } @@ -190,25 +190,24 @@ void test_vsuxseg4ei16_v_u64m2x4(uint64_t *rs1, vuint16mf2_t vs2, return __riscv_vsuxseg4ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg4ei16_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg4ei16_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x4_t vs3, - size_t vl) { +void test_vsuxseg4ei16_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei16_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint16m2_t vs2, +void test_vsuxseg4ei16_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint16m2_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg4ei32.c b/auto-generated/overloaded-api-testing/vsuxseg4ei32.c index a1437a4f2..78dffd0fd 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg4ei32.c +++ b/auto-generated/overloaded-api-testing/vsuxseg4ei32.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg4ei32_v_f16mf4x4(float16_t *rs1, vuint32mf2_t vs2, +void test_vsuxseg4ei32_v_f16mf4x4(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16mf2x4(float16_t *rs1, vuint32m1_t vs2, +void test_vsuxseg4ei32_v_f16mf2x4(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16m1x4(float16_t *rs1, vuint32m2_t vs2, +void test_vsuxseg4ei32_v_f16m1x4(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16m2x4(float16_t *rs1, vuint32m4_t vs2, +void test_vsuxseg4ei32_v_f16m2x4(_Float16 *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32(rs1, vs2, vs3, vl); } @@ -190,25 +190,24 @@ void test_vsuxseg4ei32_v_u64m2x4(uint64_t *rs1, vuint32m1_t vs2, return __riscv_vsuxseg4ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg4ei32_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg4ei32_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x4_t vs3, - size_t vl) { +void test_vsuxseg4ei32_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei32_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint32m4_t vs2, +void test_vsuxseg4ei32_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint32m4_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg4ei64.c b/auto-generated/overloaded-api-testing/vsuxseg4ei64.c index 31d3ce413..63e173ab6 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg4ei64.c +++ b/auto-generated/overloaded-api-testing/vsuxseg4ei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg4ei64_v_f16mf4x4(float16_t *rs1, vuint64m1_t vs2, +void test_vsuxseg4ei64_v_f16mf4x4(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16mf2x4(float16_t *rs1, vuint64m2_t vs2, +void test_vsuxseg4ei64_v_f16mf2x4(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16m1x4(float16_t *rs1, vuint64m4_t vs2, +void test_vsuxseg4ei64_v_f16m1x4(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16m2x4(float16_t *rs1, vuint64m8_t vs2, +void test_vsuxseg4ei64_v_f16m2x4(_Float16 *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64(rs1, vs2, vs3, vl); } @@ -180,25 +180,24 @@ void test_vsuxseg4ei64_v_u64m2x4(uint64_t *rs1, vuint64m2_t vs2, return __riscv_vsuxseg4ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg4ei64_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg4ei64_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x4_t vs3, - size_t vl) { +void test_vsuxseg4ei64_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei64_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint64m8_t vs2, +void test_vsuxseg4ei64_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint64m8_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg4ei8.c b/auto-generated/overloaded-api-testing/vsuxseg4ei8.c index 0795b6f70..bb46bf136 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg4ei8.c +++ b/auto-generated/overloaded-api-testing/vsuxseg4ei8.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg4ei8_v_f16mf4x4(float16_t *rs1, vuint8mf8_t vs2, +void test_vsuxseg4ei8_v_f16mf4x4(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16mf2x4(float16_t *rs1, vuint8mf4_t vs2, +void test_vsuxseg4ei8_v_f16mf2x4(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16m1x4(float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg4ei8_v_f16m1x4(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16m2x4(float16_t *rs1, vuint8m1_t vs2, +void test_vsuxseg4ei8_v_f16m2x4(_Float16 *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8(rs1, vs2, vs3, vl); } @@ -190,24 +190,22 @@ void test_vsuxseg4ei8_v_u64m2x4(uint64_t *rs1, vuint8mf4_t vs2, return __riscv_vsuxseg4ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16mf4x4_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x4_t vs3, - size_t vl) { +void test_vsuxseg4ei8_v_f16mf4x4_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16mf2x4_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x4_t vs3, - size_t vl) { +void test_vsuxseg4ei8_v_f16mf2x4_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16m1x4_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg4ei8_v_f16m1x4_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg4ei8_v_f16m2x4_m(vbool8_t vm, float16_t *rs1, vuint8m1_t vs2, +void test_vsuxseg4ei8_v_f16m2x4_m(vbool8_t vm, _Float16 *rs1, vuint8m1_t vs2, vfloat16m2x4_t vs3, size_t vl) { return __riscv_vsuxseg4ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg5ei16.c b/auto-generated/overloaded-api-testing/vsuxseg5ei16.c index b395ef766..473b383f4 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg5ei16.c +++ b/auto-generated/overloaded-api-testing/vsuxseg5ei16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg5ei16_v_f16mf4x5(float16_t *rs1, vuint16mf4_t vs2, +void test_vsuxseg5ei16_v_f16mf4x5(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16mf2x5(float16_t *rs1, vuint16mf2_t vs2, +void test_vsuxseg5ei16_v_f16mf2x5(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16m1x5(float16_t *rs1, vuint16m1_t vs2, +void test_vsuxseg5ei16_v_f16m1x5(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg5ei16_v_u64m1x5(uint64_t *rs1, vuint16mf4_t vs2, return __riscv_vsuxseg5ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg5ei16_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg5ei16_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei16_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x5_t vs3, - size_t vl) { +void test_vsuxseg5ei16_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg5ei32.c b/auto-generated/overloaded-api-testing/vsuxseg5ei32.c index 7c38f38b9..9a98382b2 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg5ei32.c +++ b/auto-generated/overloaded-api-testing/vsuxseg5ei32.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg5ei32_v_f16mf4x5(float16_t *rs1, vuint32mf2_t vs2, +void test_vsuxseg5ei32_v_f16mf4x5(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16mf2x5(float16_t *rs1, vuint32m1_t vs2, +void test_vsuxseg5ei32_v_f16mf2x5(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16m1x5(float16_t *rs1, vuint32m2_t vs2, +void test_vsuxseg5ei32_v_f16m1x5(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg5ei32_v_u64m1x5(uint64_t *rs1, vuint32mf2_t vs2, return __riscv_vsuxseg5ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg5ei32_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg5ei32_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei32_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x5_t vs3, - size_t vl) { +void test_vsuxseg5ei32_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg5ei64.c b/auto-generated/overloaded-api-testing/vsuxseg5ei64.c index 00f13e847..dd85b6bc9 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg5ei64.c +++ b/auto-generated/overloaded-api-testing/vsuxseg5ei64.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg5ei64_v_f16mf4x5(float16_t *rs1, vuint64m1_t vs2, +void test_vsuxseg5ei64_v_f16mf4x5(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16mf2x5(float16_t *rs1, vuint64m2_t vs2, +void test_vsuxseg5ei64_v_f16mf2x5(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16m1x5(float16_t *rs1, vuint64m4_t vs2, +void test_vsuxseg5ei64_v_f16m1x5(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg5ei64_v_u64m1x5(uint64_t *rs1, vuint64m1_t vs2, return __riscv_vsuxseg5ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg5ei64_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg5ei64_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei64_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x5_t vs3, - size_t vl) { +void test_vsuxseg5ei64_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg5ei8.c b/auto-generated/overloaded-api-testing/vsuxseg5ei8.c index 9113e0dd6..3d683c5cd 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg5ei8.c +++ b/auto-generated/overloaded-api-testing/vsuxseg5ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg5ei8_v_f16mf4x5(float16_t *rs1, vuint8mf8_t vs2, +void test_vsuxseg5ei8_v_f16mf4x5(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16mf2x5(float16_t *rs1, vuint8mf4_t vs2, +void test_vsuxseg5ei8_v_f16mf2x5(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16m1x5(float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg5ei8_v_f16m1x5(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8(rs1, vs2, vs3, vl); } @@ -135,19 +135,17 @@ void test_vsuxseg5ei8_v_u64m1x5(uint64_t *rs1, vuint8mf8_t vs2, return __riscv_vsuxseg5ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16mf4x5_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x5_t vs3, - size_t vl) { +void test_vsuxseg5ei8_v_f16mf4x5_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16mf2x5_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x5_t vs3, - size_t vl) { +void test_vsuxseg5ei8_v_f16mf2x5_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg5ei8_v_f16m1x5_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg5ei8_v_f16m1x5_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x5_t vs3, size_t vl) { return __riscv_vsuxseg5ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg6ei16.c b/auto-generated/overloaded-api-testing/vsuxseg6ei16.c index 6ef0a3b9a..b963ec6df 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg6ei16.c +++ b/auto-generated/overloaded-api-testing/vsuxseg6ei16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg6ei16_v_f16mf4x6(float16_t *rs1, vuint16mf4_t vs2, +void test_vsuxseg6ei16_v_f16mf4x6(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16mf2x6(float16_t *rs1, vuint16mf2_t vs2, +void test_vsuxseg6ei16_v_f16mf2x6(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16m1x6(float16_t *rs1, vuint16m1_t vs2, +void test_vsuxseg6ei16_v_f16m1x6(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg6ei16_v_u64m1x6(uint64_t *rs1, vuint16mf4_t vs2, return __riscv_vsuxseg6ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg6ei16_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg6ei16_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei16_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x6_t vs3, - size_t vl) { +void test_vsuxseg6ei16_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg6ei32.c b/auto-generated/overloaded-api-testing/vsuxseg6ei32.c index 160d27d01..ed35bba9d 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg6ei32.c +++ b/auto-generated/overloaded-api-testing/vsuxseg6ei32.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg6ei32_v_f16mf4x6(float16_t *rs1, vuint32mf2_t vs2, +void test_vsuxseg6ei32_v_f16mf4x6(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16mf2x6(float16_t *rs1, vuint32m1_t vs2, +void test_vsuxseg6ei32_v_f16mf2x6(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16m1x6(float16_t *rs1, vuint32m2_t vs2, +void test_vsuxseg6ei32_v_f16m1x6(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg6ei32_v_u64m1x6(uint64_t *rs1, vuint32mf2_t vs2, return __riscv_vsuxseg6ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg6ei32_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg6ei32_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei32_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x6_t vs3, - size_t vl) { +void test_vsuxseg6ei32_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg6ei64.c b/auto-generated/overloaded-api-testing/vsuxseg6ei64.c index b0808c223..ca2bb8df3 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg6ei64.c +++ b/auto-generated/overloaded-api-testing/vsuxseg6ei64.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg6ei64_v_f16mf4x6(float16_t *rs1, vuint64m1_t vs2, +void test_vsuxseg6ei64_v_f16mf4x6(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16mf2x6(float16_t *rs1, vuint64m2_t vs2, +void test_vsuxseg6ei64_v_f16mf2x6(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16m1x6(float16_t *rs1, vuint64m4_t vs2, +void test_vsuxseg6ei64_v_f16m1x6(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg6ei64_v_u64m1x6(uint64_t *rs1, vuint64m1_t vs2, return __riscv_vsuxseg6ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg6ei64_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg6ei64_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei64_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x6_t vs3, - size_t vl) { +void test_vsuxseg6ei64_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg6ei8.c b/auto-generated/overloaded-api-testing/vsuxseg6ei8.c index 6448e6ea9..d891eeb28 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg6ei8.c +++ b/auto-generated/overloaded-api-testing/vsuxseg6ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg6ei8_v_f16mf4x6(float16_t *rs1, vuint8mf8_t vs2, +void test_vsuxseg6ei8_v_f16mf4x6(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16mf2x6(float16_t *rs1, vuint8mf4_t vs2, +void test_vsuxseg6ei8_v_f16mf2x6(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16m1x6(float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg6ei8_v_f16m1x6(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8(rs1, vs2, vs3, vl); } @@ -135,19 +135,17 @@ void test_vsuxseg6ei8_v_u64m1x6(uint64_t *rs1, vuint8mf8_t vs2, return __riscv_vsuxseg6ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16mf4x6_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x6_t vs3, - size_t vl) { +void test_vsuxseg6ei8_v_f16mf4x6_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16mf2x6_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x6_t vs3, - size_t vl) { +void test_vsuxseg6ei8_v_f16mf2x6_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg6ei8_v_f16m1x6_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg6ei8_v_f16m1x6_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x6_t vs3, size_t vl) { return __riscv_vsuxseg6ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg7ei16.c b/auto-generated/overloaded-api-testing/vsuxseg7ei16.c index ded0bf74d..44fc7ddef 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg7ei16.c +++ b/auto-generated/overloaded-api-testing/vsuxseg7ei16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg7ei16_v_f16mf4x7(float16_t *rs1, vuint16mf4_t vs2, +void test_vsuxseg7ei16_v_f16mf4x7(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16mf2x7(float16_t *rs1, vuint16mf2_t vs2, +void test_vsuxseg7ei16_v_f16mf2x7(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16m1x7(float16_t *rs1, vuint16m1_t vs2, +void test_vsuxseg7ei16_v_f16m1x7(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg7ei16_v_u64m1x7(uint64_t *rs1, vuint16mf4_t vs2, return __riscv_vsuxseg7ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg7ei16_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg7ei16_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei16_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x7_t vs3, - size_t vl) { +void test_vsuxseg7ei16_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg7ei32.c b/auto-generated/overloaded-api-testing/vsuxseg7ei32.c index 3fa539f9c..6129bb992 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg7ei32.c +++ b/auto-generated/overloaded-api-testing/vsuxseg7ei32.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg7ei32_v_f16mf4x7(float16_t *rs1, vuint32mf2_t vs2, +void test_vsuxseg7ei32_v_f16mf4x7(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16mf2x7(float16_t *rs1, vuint32m1_t vs2, +void test_vsuxseg7ei32_v_f16mf2x7(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16m1x7(float16_t *rs1, vuint32m2_t vs2, +void test_vsuxseg7ei32_v_f16m1x7(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg7ei32_v_u64m1x7(uint64_t *rs1, vuint32mf2_t vs2, return __riscv_vsuxseg7ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg7ei32_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg7ei32_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei32_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x7_t vs3, - size_t vl) { +void test_vsuxseg7ei32_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg7ei64.c b/auto-generated/overloaded-api-testing/vsuxseg7ei64.c index e29ee6c1b..4b5b6bdf6 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg7ei64.c +++ b/auto-generated/overloaded-api-testing/vsuxseg7ei64.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg7ei64_v_f16mf4x7(float16_t *rs1, vuint64m1_t vs2, +void test_vsuxseg7ei64_v_f16mf4x7(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16mf2x7(float16_t *rs1, vuint64m2_t vs2, +void test_vsuxseg7ei64_v_f16mf2x7(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16m1x7(float16_t *rs1, vuint64m4_t vs2, +void test_vsuxseg7ei64_v_f16m1x7(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg7ei64_v_u64m1x7(uint64_t *rs1, vuint64m1_t vs2, return __riscv_vsuxseg7ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg7ei64_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg7ei64_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei64_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x7_t vs3, - size_t vl) { +void test_vsuxseg7ei64_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg7ei8.c b/auto-generated/overloaded-api-testing/vsuxseg7ei8.c index 81353a3f0..0eddae3fb 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg7ei8.c +++ b/auto-generated/overloaded-api-testing/vsuxseg7ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg7ei8_v_f16mf4x7(float16_t *rs1, vuint8mf8_t vs2, +void test_vsuxseg7ei8_v_f16mf4x7(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16mf2x7(float16_t *rs1, vuint8mf4_t vs2, +void test_vsuxseg7ei8_v_f16mf2x7(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16m1x7(float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg7ei8_v_f16m1x7(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8(rs1, vs2, vs3, vl); } @@ -135,19 +135,17 @@ void test_vsuxseg7ei8_v_u64m1x7(uint64_t *rs1, vuint8mf8_t vs2, return __riscv_vsuxseg7ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16mf4x7_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x7_t vs3, - size_t vl) { +void test_vsuxseg7ei8_v_f16mf4x7_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16mf2x7_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x7_t vs3, - size_t vl) { +void test_vsuxseg7ei8_v_f16mf2x7_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg7ei8_v_f16m1x7_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg7ei8_v_f16m1x7_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x7_t vs3, size_t vl) { return __riscv_vsuxseg7ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg8ei16.c b/auto-generated/overloaded-api-testing/vsuxseg8ei16.c index 20e479d2b..50d6a3017 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg8ei16.c +++ b/auto-generated/overloaded-api-testing/vsuxseg8ei16.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg8ei16_v_f16mf4x8(float16_t *rs1, vuint16mf4_t vs2, +void test_vsuxseg8ei16_v_f16mf4x8(_Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16mf2x8(float16_t *rs1, vuint16mf2_t vs2, +void test_vsuxseg8ei16_v_f16mf2x8(_Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16m1x8(float16_t *rs1, vuint16m1_t vs2, +void test_vsuxseg8ei16_v_f16m1x8(_Float16 *rs1, vuint16m1_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg8ei16_v_u64m1x8(uint64_t *rs1, vuint16mf4_t vs2, return __riscv_vsuxseg8ei16(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg8ei16_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint16mf4_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg8ei16_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint16mf2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei16_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, - vuint16m1_t vs2, vfloat16m1x8_t vs3, - size_t vl) { +void test_vsuxseg8ei16_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint16m1_t vs2, + vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei16(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg8ei32.c b/auto-generated/overloaded-api-testing/vsuxseg8ei32.c index b2820ed8e..1e1e8fa70 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg8ei32.c +++ b/auto-generated/overloaded-api-testing/vsuxseg8ei32.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg8ei32_v_f16mf4x8(float16_t *rs1, vuint32mf2_t vs2, +void test_vsuxseg8ei32_v_f16mf4x8(_Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16mf2x8(float16_t *rs1, vuint32m1_t vs2, +void test_vsuxseg8ei32_v_f16mf2x8(_Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16m1x8(float16_t *rs1, vuint32m2_t vs2, +void test_vsuxseg8ei32_v_f16m1x8(_Float16 *rs1, vuint32m2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg8ei32_v_u64m1x8(uint64_t *rs1, vuint32mf2_t vs2, return __riscv_vsuxseg8ei32(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg8ei32_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint32mf2_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg8ei32_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint32m1_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei32_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, - vuint32m2_t vs2, vfloat16m1x8_t vs3, - size_t vl) { +void test_vsuxseg8ei32_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint32m2_t vs2, + vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei32(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg8ei64.c b/auto-generated/overloaded-api-testing/vsuxseg8ei64.c index 4b3b57f35..96a6cf98e 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg8ei64.c +++ b/auto-generated/overloaded-api-testing/vsuxseg8ei64.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg8ei64_v_f16mf4x8(float16_t *rs1, vuint64m1_t vs2, +void test_vsuxseg8ei64_v_f16mf4x8(_Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16mf2x8(float16_t *rs1, vuint64m2_t vs2, +void test_vsuxseg8ei64_v_f16mf2x8(_Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16m1x8(float16_t *rs1, vuint64m4_t vs2, +void test_vsuxseg8ei64_v_f16m1x8(_Float16 *rs1, vuint64m4_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64(rs1, vs2, vs3, vl); } @@ -135,21 +135,20 @@ void test_vsuxseg8ei64_v_u64m1x8(uint64_t *rs1, vuint64m1_t vs2, return __riscv_vsuxseg8ei64(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, +void test_vsuxseg8ei64_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint64m1_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, +void test_vsuxseg8ei64_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint64m2_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei64_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, - vuint64m4_t vs2, vfloat16m1x8_t vs3, - size_t vl) { +void test_vsuxseg8ei64_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint64m4_t vs2, + vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei64(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/overloaded-api-testing/vsuxseg8ei8.c b/auto-generated/overloaded-api-testing/vsuxseg8ei8.c index 917275ea0..c7c3ee840 100644 --- a/auto-generated/overloaded-api-testing/vsuxseg8ei8.c +++ b/auto-generated/overloaded-api-testing/vsuxseg8ei8.c @@ -5,17 +5,17 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -void test_vsuxseg8ei8_v_f16mf4x8(float16_t *rs1, vuint8mf8_t vs2, +void test_vsuxseg8ei8_v_f16mf4x8(_Float16 *rs1, vuint8mf8_t vs2, vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16mf2x8(float16_t *rs1, vuint8mf4_t vs2, +void test_vsuxseg8ei8_v_f16mf2x8(_Float16 *rs1, vuint8mf4_t vs2, vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16m1x8(float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg8ei8_v_f16m1x8(_Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8(rs1, vs2, vs3, vl); } @@ -135,19 +135,17 @@ void test_vsuxseg8ei8_v_u64m1x8(uint64_t *rs1, vuint8mf8_t vs2, return __riscv_vsuxseg8ei8(rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16mf4x8_m(vbool64_t vm, float16_t *rs1, - vuint8mf8_t vs2, vfloat16mf4x8_t vs3, - size_t vl) { +void test_vsuxseg8ei8_v_f16mf4x8_m(vbool64_t vm, _Float16 *rs1, vuint8mf8_t vs2, + vfloat16mf4x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16mf2x8_m(vbool32_t vm, float16_t *rs1, - vuint8mf4_t vs2, vfloat16mf2x8_t vs3, - size_t vl) { +void test_vsuxseg8ei8_v_f16mf2x8_m(vbool32_t vm, _Float16 *rs1, vuint8mf4_t vs2, + vfloat16mf2x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8(vm, rs1, vs2, vs3, vl); } -void test_vsuxseg8ei8_v_f16m1x8_m(vbool16_t vm, float16_t *rs1, vuint8mf2_t vs2, +void test_vsuxseg8ei8_v_f16m1x8_m(vbool16_t vm, _Float16 *rs1, vuint8mf2_t vs2, vfloat16m1x8_t vs3, size_t vl) { return __riscv_vsuxseg8ei8(vm, rs1, vs2, vs3, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vle16.c b/auto-generated/policy_funcs/api-testing/vle16.c index ecd143dcc..c1f9478f0 100644 --- a/auto-generated/policy_funcs/api-testing/vle16.c +++ b/auto-generated/policy_funcs/api-testing/vle16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vle16_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vle16_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf4_tu(vd, rs1, vl); } -vfloat16mf2_t test_vle16_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vle16_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf2_tu(vd, rs1, vl); } -vfloat16m1_t test_vle16_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vle16_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m1_tu(vd, rs1, vl); } -vfloat16m2_t test_vle16_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vle16_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m2_tu(vd, rs1, vl); } -vfloat16m4_t test_vle16_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vle16_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m4_tu(vd, rs1, vl); } -vfloat16m8_t test_vle16_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, +vfloat16m8_t test_vle16_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m8_tu(vd, rs1, vl); } @@ -92,32 +92,32 @@ vuint16m8_t test_vle16_v_u16m8_tu(vuint16m8_t vd, const uint16_t *rs1, } vfloat16mf4_t test_vle16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf4_tum(vm, vd, rs1, vl); } vfloat16mf2_t test_vle16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf2_tum(vm, vd, rs1, vl); } vfloat16m1_t test_vle16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m1_tum(vm, vd, rs1, vl); } vfloat16m2_t test_vle16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m2_tum(vm, vd, rs1, vl); } vfloat16m4_t test_vle16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m4_tum(vm, vd, rs1, vl); } vfloat16m8_t test_vle16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m8_tum(vm, vd, rs1, vl); } @@ -182,32 +182,32 @@ vuint16m8_t test_vle16_v_u16m8_tum(vbool2_t vm, vuint16m8_t vd, } vfloat16mf4_t test_vle16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf4_tumu(vm, vd, rs1, vl); } vfloat16mf2_t test_vle16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf2_tumu(vm, vd, rs1, vl); } vfloat16m1_t test_vle16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m1_tumu(vm, vd, rs1, vl); } vfloat16m2_t test_vle16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m2_tumu(vm, vd, rs1, vl); } vfloat16m4_t test_vle16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m4_tumu(vm, vd, rs1, vl); } vfloat16m8_t test_vle16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m8_tumu(vm, vd, rs1, vl); } @@ -272,32 +272,32 @@ vuint16m8_t test_vle16_v_u16m8_tumu(vbool2_t vm, vuint16m8_t vd, } vfloat16mf4_t test_vle16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf4_mu(vm, vd, rs1, vl); } vfloat16mf2_t test_vle16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf2_mu(vm, vd, rs1, vl); } vfloat16m1_t test_vle16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m1_mu(vm, vd, rs1, vl); } vfloat16m2_t test_vle16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m2_mu(vm, vd, rs1, vl); } vfloat16m4_t test_vle16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m4_mu(vm, vd, rs1, vl); } vfloat16m8_t test_vle16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m8_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vle16ff.c b/auto-generated/policy_funcs/api-testing/vle16ff.c index 8ba1182cd..a7343d3ad 100644 --- a/auto-generated/policy_funcs/api-testing/vle16ff.c +++ b/auto-generated/policy_funcs/api-testing/vle16ff.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vle16ff_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vle16ff_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf4_tu(vd, rs1, new_vl, vl); } -vfloat16mf2_t test_vle16ff_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vle16ff_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf2_tu(vd, rs1, new_vl, vl); } -vfloat16m1_t test_vle16ff_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vle16ff_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m1_tu(vd, rs1, new_vl, vl); } -vfloat16m2_t test_vle16ff_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vle16ff_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m2_tu(vd, rs1, new_vl, vl); } -vfloat16m4_t test_vle16ff_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vle16ff_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m4_tu(vd, rs1, new_vl, vl); } -vfloat16m8_t test_vle16ff_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, +vfloat16m8_t test_vle16ff_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m8_tu(vd, rs1, new_vl, vl); } @@ -96,37 +96,37 @@ vuint16m8_t test_vle16ff_v_u16m8_tu(vuint16m8_t vd, const uint16_t *rs1, } vfloat16mf4_t test_vle16ff_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf4_tum(vm, vd, rs1, new_vl, vl); } vfloat16mf2_t test_vle16ff_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf2_tum(vm, vd, rs1, new_vl, vl); } vfloat16m1_t test_vle16ff_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m1_tum(vm, vd, rs1, new_vl, vl); } vfloat16m2_t test_vle16ff_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m2_tum(vm, vd, rs1, new_vl, vl); } vfloat16m4_t test_vle16ff_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m4_tum(vm, vd, rs1, new_vl, vl); } vfloat16m8_t test_vle16ff_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m8_tum(vm, vd, rs1, new_vl, vl); } @@ -204,37 +204,37 @@ vuint16m8_t test_vle16ff_v_u16m8_tum(vbool2_t vm, vuint16m8_t vd, } vfloat16mf4_t test_vle16ff_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf4_tumu(vm, vd, rs1, new_vl, vl); } vfloat16mf2_t test_vle16ff_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf2_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m1_t test_vle16ff_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m1_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m2_t test_vle16ff_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m2_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m4_t test_vle16ff_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m4_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m8_t test_vle16ff_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m8_tumu(vm, vd, rs1, new_vl, vl); } @@ -312,37 +312,37 @@ vuint16m8_t test_vle16ff_v_u16m8_tumu(vbool2_t vm, vuint16m8_t vd, } vfloat16mf4_t test_vle16ff_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf4_mu(vm, vd, rs1, new_vl, vl); } vfloat16mf2_t test_vle16ff_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf2_mu(vm, vd, rs1, new_vl, vl); } vfloat16m1_t test_vle16ff_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m1_mu(vm, vd, rs1, new_vl, vl); } vfloat16m2_t test_vle16ff_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m2_mu(vm, vd, rs1, new_vl, vl); } vfloat16m4_t test_vle16ff_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m4_mu(vm, vd, rs1, new_vl, vl); } vfloat16m8_t test_vle16ff_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m8_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxei16.c b/auto-generated/policy_funcs/api-testing/vloxei16.c index b649e6b85..7910ca55f 100644 --- a/auto-generated/policy_funcs/api-testing/vloxei16.c +++ b/auto-generated/policy_funcs/api-testing/vloxei16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei16_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vloxei16_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vloxei16_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vloxei16_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vloxei16_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m2_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vloxei16_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m4_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, +vfloat16m8_t test_vloxei16_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m8_tu(vd, rs1, rs2, vl); } @@ -291,37 +291,37 @@ vuint64m8_t test_vloxei16_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, } vfloat16mf4_t test_vloxei16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint16mf4_t rs2, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint16mf2_t rs2, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint16m1_t rs2, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m1_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint16m2_t rs2, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m2_tum(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint16m4_t rs2, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m4_tum(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vloxei16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint16m8_t rs2, + const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m8_tum(vm, vd, rs1, rs2, vl); } @@ -630,37 +630,37 @@ vuint64m8_t test_vloxei16_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vloxei16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, - vuint16mf4_t rs2, size_t vl) { + const _Float16 *rs1, vuint16mf4_t rs2, + size_t vl) { return __riscv_vloxei16_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, - vuint16mf2_t rs2, size_t vl) { + const _Float16 *rs1, vuint16mf2_t rs2, + size_t vl) { return __riscv_vloxei16_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint16m1_t rs2, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint16m2_t rs2, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint16m4_t rs2, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vloxei16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint16m8_t rs2, + const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m8_tumu(vm, vd, rs1, rs2, vl); } @@ -972,37 +972,37 @@ vuint64m8_t test_vloxei16_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vloxei16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint16mf4_t rs2, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint16mf2_t rs2, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint16m1_t rs2, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m1_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint16m2_t rs2, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m2_mu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint16m4_t rs2, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m4_mu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vloxei16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint16m8_t rs2, + const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxei32.c b/auto-generated/policy_funcs/api-testing/vloxei32.c index 1cd127384..d82cd6362 100644 --- a/auto-generated/policy_funcs/api-testing/vloxei32.c +++ b/auto-generated/policy_funcs/api-testing/vloxei32.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei32_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vloxei32_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vloxei32_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vloxei32_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vloxei32_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m2_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vloxei32_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m4_tu(vd, rs1, rs2, vl); } @@ -266,31 +266,31 @@ vuint64m8_t test_vloxei32_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, } vfloat16mf4_t test_vloxei32_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint32mf2_t rs2, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei32_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint32m1_t rs2, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei32_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint32m2_t rs2, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m1_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei32_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint32m4_t rs2, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m2_tum(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei32_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint32m8_t rs2, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m4_tum(vm, vd, rs1, rs2, vl); } @@ -576,31 +576,31 @@ vuint64m8_t test_vloxei32_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vloxei32_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, - vuint32mf2_t rs2, size_t vl) { + const _Float16 *rs1, vuint32mf2_t rs2, + size_t vl) { return __riscv_vloxei32_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei32_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint32m1_t rs2, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei32_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint32m2_t rs2, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei32_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint32m4_t rs2, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei32_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint32m8_t rs2, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m4_tumu(vm, vd, rs1, rs2, vl); } @@ -888,31 +888,31 @@ vuint64m8_t test_vloxei32_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vloxei32_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint32mf2_t rs2, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei32_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint32m1_t rs2, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei32_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint32m2_t rs2, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m1_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei32_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint32m4_t rs2, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m2_mu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei32_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint32m8_t rs2, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxei64.c b/auto-generated/policy_funcs/api-testing/vloxei64.c index 4102d832b..71eac6d58 100644 --- a/auto-generated/policy_funcs/api-testing/vloxei64.c +++ b/auto-generated/policy_funcs/api-testing/vloxei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei64_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vloxei64_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vloxei64_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vloxei64_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vloxei64_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m2_tu(vd, rs1, rs2, vl); } @@ -226,25 +226,25 @@ vuint64m8_t test_vloxei64_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, } vfloat16mf4_t test_vloxei64_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint64m1_t rs2, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei64_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint64m2_t rs2, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei64_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint64m4_t rs2, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m1_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei64_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint64m8_t rs2, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m2_tum(vm, vd, rs1, rs2, vl); } @@ -489,25 +489,25 @@ vuint64m8_t test_vloxei64_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vloxei64_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint64m1_t rs2, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei64_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint64m2_t rs2, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei64_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint64m4_t rs2, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei64_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint64m8_t rs2, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } @@ -753,25 +753,25 @@ vuint64m8_t test_vloxei64_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vloxei64_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint64m1_t rs2, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei64_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint64m2_t rs2, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei64_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint64m4_t rs2, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m1_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei64_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint64m8_t rs2, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxei8.c b/auto-generated/policy_funcs/api-testing/vloxei8.c index bd63ad42e..0029fc309 100644 --- a/auto-generated/policy_funcs/api-testing/vloxei8.c +++ b/auto-generated/policy_funcs/api-testing/vloxei8.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei8_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vloxei8_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vloxei8_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vloxei8_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vloxei8_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m2_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vloxei8_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m4_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, +vfloat16m8_t test_vloxei8_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m8_tu(vd, rs1, rs2, vl); } @@ -301,37 +301,37 @@ vuint64m8_t test_vloxei8_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, } vfloat16mf4_t test_vloxei8_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint8mf8_t rs2, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei8_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint8mf4_t rs2, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei8_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint8mf2_t rs2, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m1_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei8_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint8m1_t rs2, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m2_tum(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei8_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint8m2_t rs2, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m4_tum(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vloxei8_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint8m4_t rs2, + const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m8_tum(vm, vd, rs1, rs2, vl); } @@ -651,37 +651,37 @@ vuint64m8_t test_vloxei8_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vloxei8_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint8mf8_t rs2, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei8_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint8mf4_t rs2, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei8_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint8mf2_t rs2, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei8_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint8m1_t rs2, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei8_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint8m2_t rs2, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vloxei8_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint8m4_t rs2, + const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m8_tumu(vm, vd, rs1, rs2, vl); } @@ -1001,37 +1001,37 @@ vuint64m8_t test_vloxei8_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vloxei8_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint8mf8_t rs2, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei8_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint8mf4_t rs2, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei8_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint8mf2_t rs2, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m1_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei8_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint8m1_t rs2, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m2_mu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei8_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint8m2_t rs2, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m4_mu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vloxei8_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint8m4_t rs2, + const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg2ei16.c b/auto-generated/policy_funcs/api-testing/vloxseg2ei16.c index f06de2953..429fe0767 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg2ei16.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg2ei16.c @@ -6,31 +6,31 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf4x2_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf2x2_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m1x2_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m2x2_tu(vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m4x2_tu(vd, rs1, rs2, vl); } @@ -277,32 +277,32 @@ vuint64m4x2_t test_vloxseg2ei16_v_u64m4x2_tu(vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m4x2_tum(vm, vd, rs1, rs2, vl); } @@ -568,32 +568,32 @@ vuint64m4x2_t test_vloxseg2ei16_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m4x2_tumu(vm, vd, rs1, rs2, vl); } @@ -862,32 +862,32 @@ vuint64m4x2_t test_vloxseg2ei16_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m4x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg2ei32.c b/auto-generated/policy_funcs/api-testing/vloxseg2ei32.c index df3be7e12..8f1b1a6df 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg2ei32.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg2ei32.c @@ -6,31 +6,31 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf4x2_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf2x2_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m1x2_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m2x2_tu(vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m4x2_tu(vd, rs1, rs2, vl); } @@ -267,32 +267,32 @@ vuint64m4x2_t test_vloxseg2ei32_v_u64m4x2_tu(vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m4x2_tum(vm, vd, rs1, rs2, vl); } @@ -546,32 +546,32 @@ vuint64m4x2_t test_vloxseg2ei32_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m4x2_tumu(vm, vd, rs1, rs2, vl); } @@ -828,32 +828,32 @@ vuint64m4x2_t test_vloxseg2ei32_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m4x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg2ei64.c b/auto-generated/policy_funcs/api-testing/vloxseg2ei64.c index a7f6d84df..4f216ca5a 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg2ei64.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg2ei64.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf4x2_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf2x2_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m1x2_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m2x2_tu(vd, rs1, rs2, vl); } @@ -240,26 +240,26 @@ vuint64m4x2_t test_vloxseg2ei64_v_u64m4x2_tu(vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } @@ -489,26 +489,26 @@ vuint64m4x2_t test_vloxseg2ei64_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } @@ -741,26 +741,26 @@ vuint64m4x2_t test_vloxseg2ei64_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg2ei8.c b/auto-generated/policy_funcs/api-testing/vloxseg2ei8.c index da43995c7..5c71449f3 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg2ei8.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg2ei8.c @@ -6,31 +6,31 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf4x2_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf2x2_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m1x2_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m2x2_tu(vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m4x2_tu(vd, rs1, rs2, vl); } @@ -277,32 +277,32 @@ vuint64m4x2_t test_vloxseg2ei8_v_u64m4x2_tu(vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m4x2_tum(vm, vd, rs1, rs2, vl); } @@ -568,32 +568,32 @@ vuint64m4x2_t test_vloxseg2ei8_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m4x2_tumu(vm, vd, rs1, rs2, vl); } @@ -858,31 +858,31 @@ vuint64m4x2_t test_vloxseg2ei8_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, } vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m4x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg3ei16.c b/auto-generated/policy_funcs/api-testing/vloxseg3ei16.c index 91c463db6..9b0399a52 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg3ei16.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg3ei16.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf4x3_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf2x3_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m1x3_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x3_t test_vloxseg3ei16_v_u64m2x3_tu(vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x3_t test_vloxseg3ei16_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -669,26 +669,26 @@ vuint64m2x3_t test_vloxseg3ei16_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg3ei32.c b/auto-generated/policy_funcs/api-testing/vloxseg3ei32.c index 13a5a4ded..cd1858f41 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg3ei32.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg3ei32.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf4x3_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf2x3_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m1x3_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x3_t test_vloxseg3ei32_v_u64m2x3_tu(vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x3_t test_vloxseg3ei32_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -669,26 +669,26 @@ vuint64m2x3_t test_vloxseg3ei32_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg3ei64.c b/auto-generated/policy_funcs/api-testing/vloxseg3ei64.c index 23031e79f..b32d59cbd 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg3ei64.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg3ei64.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf4x3_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf2x3_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m1x3_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -206,26 +206,26 @@ vuint64m2x3_t test_vloxseg3ei64_v_u64m2x3_tu(vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -419,26 +419,26 @@ vuint64m2x3_t test_vloxseg3ei64_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -635,26 +635,26 @@ vuint64m2x3_t test_vloxseg3ei64_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg3ei8.c b/auto-generated/policy_funcs/api-testing/vloxseg3ei8.c index 58864decb..64a517dc1 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg3ei8.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg3ei8.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf4x3_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf2x3_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m1x3_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x3_t test_vloxseg3ei8_v_u64m2x3_tu(vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x3_t test_vloxseg3ei8_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -665,25 +665,25 @@ vuint64m2x3_t test_vloxseg3ei8_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, } vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg4ei16.c b/auto-generated/policy_funcs/api-testing/vloxseg4ei16.c index 9042e8dc5..888e7ef96 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg4ei16.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg4ei16.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf4x4_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf2x4_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m1x4_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x4_t test_vloxseg4ei16_v_u64m2x4_tu(vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x4_t test_vloxseg4ei16_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -669,26 +669,26 @@ vuint64m2x4_t test_vloxseg4ei16_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg4ei32.c b/auto-generated/policy_funcs/api-testing/vloxseg4ei32.c index e788be5df..574f0a569 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg4ei32.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg4ei32.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf4x4_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf2x4_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m1x4_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x4_t test_vloxseg4ei32_v_u64m2x4_tu(vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x4_t test_vloxseg4ei32_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -669,26 +669,26 @@ vuint64m2x4_t test_vloxseg4ei32_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg4ei64.c b/auto-generated/policy_funcs/api-testing/vloxseg4ei64.c index 1e2c5981f..1921d6262 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg4ei64.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg4ei64.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf4x4_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf2x4_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m1x4_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -206,26 +206,26 @@ vuint64m2x4_t test_vloxseg4ei64_v_u64m2x4_tu(vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -419,26 +419,26 @@ vuint64m2x4_t test_vloxseg4ei64_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -635,26 +635,26 @@ vuint64m2x4_t test_vloxseg4ei64_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg4ei8.c b/auto-generated/policy_funcs/api-testing/vloxseg4ei8.c index f01885f39..0e3f107a8 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg4ei8.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg4ei8.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf4x4_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf2x4_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m1x4_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x4_t test_vloxseg4ei8_v_u64m2x4_tu(vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x4_t test_vloxseg4ei8_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -665,25 +665,25 @@ vuint64m2x4_t test_vloxseg4ei8_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, } vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg5ei16.c b/auto-generated/policy_funcs/api-testing/vloxseg5ei16.c index 5210c0426..afddd04bf 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg5ei16.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg5ei16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf4x5_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf2x5_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x5_t test_vloxseg5ei16_v_u64m1x5_tu(vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x5_t test_vloxseg5ei16_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x5_t test_vloxseg5ei16_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg5ei32.c b/auto-generated/policy_funcs/api-testing/vloxseg5ei32.c index 6f0ecf286..8e9e74dbf 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg5ei32.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg5ei32.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf4x5_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf2x5_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x5_t test_vloxseg5ei32_v_u64m1x5_tu(vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x5_t test_vloxseg5ei32_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x5_t test_vloxseg5ei32_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg5ei64.c b/auto-generated/policy_funcs/api-testing/vloxseg5ei64.c index 32f579e6f..97f15404d 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg5ei64.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg5ei64.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf4x5_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf2x5_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x5_t test_vloxseg5ei64_v_u64m1x5_tu(vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x5_t test_vloxseg5ei64_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x5_t test_vloxseg5ei64_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg5ei8.c b/auto-generated/policy_funcs/api-testing/vloxseg5ei8.c index 06ebd15e9..6f15c68d0 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg5ei8.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg5ei8.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf4x5_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf2x5_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x5_t test_vloxseg5ei8_v_u64m1x5_tu(vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x5_t test_vloxseg5ei8_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -472,19 +472,19 @@ vuint64m1x5_t test_vloxseg5ei8_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, } vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg6ei16.c b/auto-generated/policy_funcs/api-testing/vloxseg6ei16.c index ce501c600..cc5caf054 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg6ei16.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg6ei16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf4x6_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf2x6_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x6_t test_vloxseg6ei16_v_u64m1x6_tu(vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x6_t test_vloxseg6ei16_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x6_t test_vloxseg6ei16_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg6ei32.c b/auto-generated/policy_funcs/api-testing/vloxseg6ei32.c index 905662f6c..44343d8e7 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg6ei32.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg6ei32.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf4x6_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf2x6_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x6_t test_vloxseg6ei32_v_u64m1x6_tu(vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x6_t test_vloxseg6ei32_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x6_t test_vloxseg6ei32_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg6ei64.c b/auto-generated/policy_funcs/api-testing/vloxseg6ei64.c index dfd0e0689..10643b4af 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg6ei64.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg6ei64.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf4x6_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf2x6_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x6_t test_vloxseg6ei64_v_u64m1x6_tu(vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x6_t test_vloxseg6ei64_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x6_t test_vloxseg6ei64_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg6ei8.c b/auto-generated/policy_funcs/api-testing/vloxseg6ei8.c index 1d31f577e..286615e7c 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg6ei8.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg6ei8.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf4x6_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf2x6_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x6_t test_vloxseg6ei8_v_u64m1x6_tu(vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x6_t test_vloxseg6ei8_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -472,19 +472,19 @@ vuint64m1x6_t test_vloxseg6ei8_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, } vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg7ei16.c b/auto-generated/policy_funcs/api-testing/vloxseg7ei16.c index a40bbb1e0..39c1169ee 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg7ei16.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg7ei16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf4x7_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf2x7_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x7_t test_vloxseg7ei16_v_u64m1x7_tu(vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x7_t test_vloxseg7ei16_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x7_t test_vloxseg7ei16_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg7ei32.c b/auto-generated/policy_funcs/api-testing/vloxseg7ei32.c index f054584d0..dff1b351f 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg7ei32.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg7ei32.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf4x7_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf2x7_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x7_t test_vloxseg7ei32_v_u64m1x7_tu(vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x7_t test_vloxseg7ei32_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x7_t test_vloxseg7ei32_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg7ei64.c b/auto-generated/policy_funcs/api-testing/vloxseg7ei64.c index febb73b1b..1df421080 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg7ei64.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg7ei64.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf4x7_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf2x7_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x7_t test_vloxseg7ei64_v_u64m1x7_tu(vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x7_t test_vloxseg7ei64_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x7_t test_vloxseg7ei64_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg7ei8.c b/auto-generated/policy_funcs/api-testing/vloxseg7ei8.c index e47ec3f52..0c296dd79 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg7ei8.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg7ei8.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf4x7_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf2x7_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x7_t test_vloxseg7ei8_v_u64m1x7_tu(vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x7_t test_vloxseg7ei8_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -472,19 +472,19 @@ vuint64m1x7_t test_vloxseg7ei8_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, } vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg8ei16.c b/auto-generated/policy_funcs/api-testing/vloxseg8ei16.c index 3d7b5389c..5f7e18cab 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg8ei16.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg8ei16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf4x8_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf2x8_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x8_t test_vloxseg8ei16_v_u64m1x8_tu(vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x8_t test_vloxseg8ei16_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x8_t test_vloxseg8ei16_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg8ei32.c b/auto-generated/policy_funcs/api-testing/vloxseg8ei32.c index 479b6c1b0..cc418eb25 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg8ei32.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg8ei32.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf4x8_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf2x8_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x8_t test_vloxseg8ei32_v_u64m1x8_tu(vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x8_t test_vloxseg8ei32_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x8_t test_vloxseg8ei32_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg8ei64.c b/auto-generated/policy_funcs/api-testing/vloxseg8ei64.c index bc75bed0c..dd02ca223 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg8ei64.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg8ei64.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf4x8_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf2x8_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x8_t test_vloxseg8ei64_v_u64m1x8_tu(vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x8_t test_vloxseg8ei64_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x8_t test_vloxseg8ei64_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vloxseg8ei8.c b/auto-generated/policy_funcs/api-testing/vloxseg8ei8.c index 0efda1127..e576da58b 100644 --- a/auto-generated/policy_funcs/api-testing/vloxseg8ei8.c +++ b/auto-generated/policy_funcs/api-testing/vloxseg8ei8.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf4x8_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf2x8_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x8_t test_vloxseg8ei8_v_u64m1x8_tu(vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x8_t test_vloxseg8ei8_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -472,19 +472,19 @@ vuint64m1x8_t test_vloxseg8ei8_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, } vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlse16.c b/auto-generated/policy_funcs/api-testing/vlse16.c index ccfb2843c..5cb034161 100644 --- a/auto-generated/policy_funcs/api-testing/vlse16.c +++ b/auto-generated/policy_funcs/api-testing/vlse16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vlse16_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vlse16_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vlse16_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vlse16_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vlse16_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vlse16_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vlse16_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vlse16_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m2_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vlse16_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vlse16_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m4_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vlse16_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, +vfloat16m8_t test_vlse16_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m8_tu(vd, rs1, rs2, vl); } @@ -96,37 +96,37 @@ vuint16m8_t test_vlse16_v_u16m8_tu(vuint16m8_t vd, const uint16_t *rs1, } vfloat16mf4_t test_vlse16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vlse16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vlse16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m1_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vlse16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m2_tum(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vlse16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m4_tum(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vlse16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m8_tum(vm, vd, rs1, rs2, vl); } @@ -204,37 +204,37 @@ vuint16m8_t test_vlse16_v_u16m8_tum(vbool2_t vm, vuint16m8_t vd, } vfloat16mf4_t test_vlse16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vlse16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vlse16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vlse16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vlse16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vlse16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m8_tumu(vm, vd, rs1, rs2, vl); } @@ -312,37 +312,37 @@ vuint16m8_t test_vlse16_v_u16m8_tumu(vbool2_t vm, vuint16m8_t vd, } vfloat16mf4_t test_vlse16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vlse16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vlse16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m1_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vlse16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m2_mu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vlse16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m4_mu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vlse16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlseg2e16.c b/auto-generated/policy_funcs/api-testing/vlseg2e16.c index 0ea8359c4..7fa358da6 100644 --- a/auto-generated/policy_funcs/api-testing/vlseg2e16.c +++ b/auto-generated/policy_funcs/api-testing/vlseg2e16.c @@ -6,27 +6,27 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf4x2_tu(vd, rs1, vl); } vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf2x2_tu(vd, rs1, vl); } vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m1x2_tu(vd, rs1, vl); } vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m2x2_tu(vd, rs1, vl); } vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m4x2_tu(vd, rs1, vl); } @@ -81,27 +81,27 @@ vuint16m4x2_t test_vlseg2e16_v_u16m4x2_tu(vuint16m4x2_t vd, const uint16_t *rs1, } vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf4x2_tum(vm, vd, rs1, vl); } vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf2x2_tum(vm, vd, rs1, vl); } vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m1x2_tum(vm, vd, rs1, vl); } vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m2x2_tum(vm, vd, rs1, vl); } vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m4x2_tum(vm, vd, rs1, vl); } @@ -156,29 +156,27 @@ vuint16m4x2_t test_vlseg2e16_v_u16m4x2_tum(vbool4_t vm, vuint16m4x2_t vd, } vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf4x2_tumu(vm, vd, rs1, vl); } vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf2x2_tumu(vm, vd, rs1, vl); } vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m1x2_tumu(vm, vd, rs1, vl); } vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m2x2_tumu(vm, vd, rs1, vl); } vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m4x2_tumu(vm, vd, rs1, vl); } @@ -233,27 +231,27 @@ vuint16m4x2_t test_vlseg2e16_v_u16m4x2_tumu(vbool4_t vm, vuint16m4x2_t vd, } vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf4x2_mu(vm, vd, rs1, vl); } vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf2x2_mu(vm, vd, rs1, vl); } vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m1x2_mu(vm, vd, rs1, vl); } vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m2x2_mu(vm, vd, rs1, vl); } vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m4x2_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlseg2e16ff.c b/auto-generated/policy_funcs/api-testing/vlseg2e16ff.c index 21ee72f18..bc3ed4e13 100644 --- a/auto-generated/policy_funcs/api-testing/vlseg2e16ff.c +++ b/auto-generated/policy_funcs/api-testing/vlseg2e16ff.c @@ -6,31 +6,31 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf4x2_tu(vd, rs1, new_vl, vl); } vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf2x2_tu(vd, rs1, new_vl, vl); } vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m1x2_tu(vd, rs1, new_vl, vl); } vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m2x2_tu(vd, rs1, new_vl, vl); } vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m4x2_tu(vd, rs1, new_vl, vl); } @@ -94,32 +94,32 @@ vuint16m4x2_t test_vlseg2e16ff_v_u16m4x2_tu(vuint16m4x2_t vd, vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf4x2_tum(vm, vd, rs1, new_vl, vl); } vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf2x2_tum(vm, vd, rs1, new_vl, vl); } vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m1x2_tum(vm, vd, rs1, new_vl, vl); } vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m2x2_tum(vm, vd, rs1, new_vl, vl); } vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m4x2_tum(vm, vd, rs1, new_vl, vl); } @@ -186,32 +186,32 @@ vuint16m4x2_t test_vlseg2e16ff_v_u16m4x2_tum(vbool4_t vm, vuint16m4x2_t vd, vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf4x2_tumu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf2x2_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m1x2_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m2x2_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m4x2_tumu(vm, vd, rs1, new_vl, vl); } @@ -277,31 +277,31 @@ vuint16m4x2_t test_vlseg2e16ff_v_u16m4x2_tumu(vbool4_t vm, vuint16m4x2_t vd, } vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf4x2_mu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf2x2_mu(vm, vd, rs1, new_vl, vl); } vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m1x2_mu(vm, vd, rs1, new_vl, vl); } vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m2x2_mu(vm, vd, rs1, new_vl, vl); } vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m4x2_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlseg3e16.c b/auto-generated/policy_funcs/api-testing/vlseg3e16.c index efd96e1f1..a775b2b32 100644 --- a/auto-generated/policy_funcs/api-testing/vlseg3e16.c +++ b/auto-generated/policy_funcs/api-testing/vlseg3e16.c @@ -6,22 +6,22 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf4x3_tu(vd, rs1, vl); } vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf2x3_tu(vd, rs1, vl); } vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m1x3_tu(vd, rs1, vl); } vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m2x3_tu(vd, rs1, vl); } @@ -66,22 +66,22 @@ vuint16m2x3_t test_vlseg3e16_v_u16m2x3_tu(vuint16m2x3_t vd, const uint16_t *rs1, } vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf4x3_tum(vm, vd, rs1, vl); } vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf2x3_tum(vm, vd, rs1, vl); } vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m1x3_tum(vm, vd, rs1, vl); } vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m2x3_tum(vm, vd, rs1, vl); } @@ -126,24 +126,22 @@ vuint16m2x3_t test_vlseg3e16_v_u16m2x3_tum(vbool8_t vm, vuint16m2x3_t vd, } vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf4x3_tumu(vm, vd, rs1, vl); } vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf2x3_tumu(vm, vd, rs1, vl); } vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m1x3_tumu(vm, vd, rs1, vl); } vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m2x3_tumu(vm, vd, rs1, vl); } @@ -188,22 +186,22 @@ vuint16m2x3_t test_vlseg3e16_v_u16m2x3_tumu(vbool8_t vm, vuint16m2x3_t vd, } vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf4x3_mu(vm, vd, rs1, vl); } vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf2x3_mu(vm, vd, rs1, vl); } vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m1x3_mu(vm, vd, rs1, vl); } vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m2x3_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlseg3e16ff.c b/auto-generated/policy_funcs/api-testing/vlseg3e16ff.c index acf29bd50..8bb7fdf6a 100644 --- a/auto-generated/policy_funcs/api-testing/vlseg3e16ff.c +++ b/auto-generated/policy_funcs/api-testing/vlseg3e16ff.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf4x3_tu(vd, rs1, new_vl, vl); } vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf2x3_tu(vd, rs1, new_vl, vl); } vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m1x3_tu(vd, rs1, new_vl, vl); } vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m2x3_tu(vd, rs1, new_vl, vl); } @@ -77,26 +77,26 @@ vuint16m2x3_t test_vlseg3e16ff_v_u16m2x3_tu(vuint16m2x3_t vd, vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf4x3_tum(vm, vd, rs1, new_vl, vl); } vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf2x3_tum(vm, vd, rs1, new_vl, vl); } vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m1x3_tum(vm, vd, rs1, new_vl, vl); } vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m2x3_tum(vm, vd, rs1, new_vl, vl); } @@ -151,26 +151,26 @@ vuint16m2x3_t test_vlseg3e16ff_v_u16m2x3_tum(vbool8_t vm, vuint16m2x3_t vd, vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf4x3_tumu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf2x3_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m1x3_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m2x3_tumu(vm, vd, rs1, new_vl, vl); } @@ -224,25 +224,25 @@ vuint16m2x3_t test_vlseg3e16ff_v_u16m2x3_tumu(vbool8_t vm, vuint16m2x3_t vd, } vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf4x3_mu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf2x3_mu(vm, vd, rs1, new_vl, vl); } vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m1x3_mu(vm, vd, rs1, new_vl, vl); } vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m2x3_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlseg4e16.c b/auto-generated/policy_funcs/api-testing/vlseg4e16.c index 2873c7968..1268b53e4 100644 --- a/auto-generated/policy_funcs/api-testing/vlseg4e16.c +++ b/auto-generated/policy_funcs/api-testing/vlseg4e16.c @@ -6,22 +6,22 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf4x4_tu(vd, rs1, vl); } vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf2x4_tu(vd, rs1, vl); } vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m1x4_tu(vd, rs1, vl); } vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m2x4_tu(vd, rs1, vl); } @@ -66,22 +66,22 @@ vuint16m2x4_t test_vlseg4e16_v_u16m2x4_tu(vuint16m2x4_t vd, const uint16_t *rs1, } vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf4x4_tum(vm, vd, rs1, vl); } vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf2x4_tum(vm, vd, rs1, vl); } vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m1x4_tum(vm, vd, rs1, vl); } vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m2x4_tum(vm, vd, rs1, vl); } @@ -126,24 +126,22 @@ vuint16m2x4_t test_vlseg4e16_v_u16m2x4_tum(vbool8_t vm, vuint16m2x4_t vd, } vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf4x4_tumu(vm, vd, rs1, vl); } vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf2x4_tumu(vm, vd, rs1, vl); } vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m1x4_tumu(vm, vd, rs1, vl); } vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m2x4_tumu(vm, vd, rs1, vl); } @@ -188,22 +186,22 @@ vuint16m2x4_t test_vlseg4e16_v_u16m2x4_tumu(vbool8_t vm, vuint16m2x4_t vd, } vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf4x4_mu(vm, vd, rs1, vl); } vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf2x4_mu(vm, vd, rs1, vl); } vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m1x4_mu(vm, vd, rs1, vl); } vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m2x4_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlseg4e16ff.c b/auto-generated/policy_funcs/api-testing/vlseg4e16ff.c index bd943948a..4557c340f 100644 --- a/auto-generated/policy_funcs/api-testing/vlseg4e16ff.c +++ b/auto-generated/policy_funcs/api-testing/vlseg4e16ff.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf4x4_tu(vd, rs1, new_vl, vl); } vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf2x4_tu(vd, rs1, new_vl, vl); } vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m1x4_tu(vd, rs1, new_vl, vl); } vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m2x4_tu(vd, rs1, new_vl, vl); } @@ -77,26 +77,26 @@ vuint16m2x4_t test_vlseg4e16ff_v_u16m2x4_tu(vuint16m2x4_t vd, vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf4x4_tum(vm, vd, rs1, new_vl, vl); } vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf2x4_tum(vm, vd, rs1, new_vl, vl); } vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m1x4_tum(vm, vd, rs1, new_vl, vl); } vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m2x4_tum(vm, vd, rs1, new_vl, vl); } @@ -151,26 +151,26 @@ vuint16m2x4_t test_vlseg4e16ff_v_u16m2x4_tum(vbool8_t vm, vuint16m2x4_t vd, vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf4x4_tumu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf2x4_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m1x4_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m2x4_tumu(vm, vd, rs1, new_vl, vl); } @@ -224,25 +224,25 @@ vuint16m2x4_t test_vlseg4e16ff_v_u16m2x4_tumu(vbool8_t vm, vuint16m2x4_t vd, } vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf4x4_mu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf2x4_mu(vm, vd, rs1, new_vl, vl); } vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m1x4_mu(vm, vd, rs1, new_vl, vl); } vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m2x4_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlseg5e16.c b/auto-generated/policy_funcs/api-testing/vlseg5e16.c index 2b5611a76..837be4a24 100644 --- a/auto-generated/policy_funcs/api-testing/vlseg5e16.c +++ b/auto-generated/policy_funcs/api-testing/vlseg5e16.c @@ -6,17 +6,17 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf4x5_tu(vd, rs1, vl); } vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf2x5_tu(vd, rs1, vl); } vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16m1x5_tu(vd, rs1, vl); } @@ -51,17 +51,17 @@ vuint16m1x5_t test_vlseg5e16_v_u16m1x5_tu(vuint16m1x5_t vd, const uint16_t *rs1, } vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf4x5_tum(vm, vd, rs1, vl); } vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf2x5_tum(vm, vd, rs1, vl); } vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16m1x5_tum(vm, vd, rs1, vl); } @@ -96,19 +96,17 @@ vuint16m1x5_t test_vlseg5e16_v_u16m1x5_tum(vbool16_t vm, vuint16m1x5_t vd, } vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf4x5_tumu(vm, vd, rs1, vl); } vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf2x5_tumu(vm, vd, rs1, vl); } vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16m1x5_tumu(vm, vd, rs1, vl); } @@ -143,17 +141,17 @@ vuint16m1x5_t test_vlseg5e16_v_u16m1x5_tumu(vbool16_t vm, vuint16m1x5_t vd, } vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf4x5_mu(vm, vd, rs1, vl); } vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf2x5_mu(vm, vd, rs1, vl); } vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16m1x5_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlseg5e16ff.c b/auto-generated/policy_funcs/api-testing/vlseg5e16ff.c index cc1c63624..0ffabd6a4 100644 --- a/auto-generated/policy_funcs/api-testing/vlseg5e16ff.c +++ b/auto-generated/policy_funcs/api-testing/vlseg5e16ff.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf4x5_tu(vd, rs1, new_vl, vl); } vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf2x5_tu(vd, rs1, new_vl, vl); } vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16m1x5_tu(vd, rs1, new_vl, vl); } @@ -60,20 +60,20 @@ vuint16m1x5_t test_vlseg5e16ff_v_u16m1x5_tu(vuint16m1x5_t vd, vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf4x5_tum(vm, vd, rs1, new_vl, vl); } vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf2x5_tum(vm, vd, rs1, new_vl, vl); } vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16m1x5_tum(vm, vd, rs1, new_vl, vl); } @@ -116,20 +116,20 @@ vuint16m1x5_t test_vlseg5e16ff_v_u16m1x5_tum(vbool16_t vm, vuint16m1x5_t vd, vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf4x5_tumu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf2x5_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16m1x5_tumu(vm, vd, rs1, new_vl, vl); } @@ -171,19 +171,19 @@ vuint16m1x5_t test_vlseg5e16ff_v_u16m1x5_tumu(vbool16_t vm, vuint16m1x5_t vd, } vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf4x5_mu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf2x5_mu(vm, vd, rs1, new_vl, vl); } vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16m1x5_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlseg6e16.c b/auto-generated/policy_funcs/api-testing/vlseg6e16.c index fc8f8d4f8..e82a7f7f2 100644 --- a/auto-generated/policy_funcs/api-testing/vlseg6e16.c +++ b/auto-generated/policy_funcs/api-testing/vlseg6e16.c @@ -6,17 +6,17 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf4x6_tu(vd, rs1, vl); } vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf2x6_tu(vd, rs1, vl); } vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16m1x6_tu(vd, rs1, vl); } @@ -51,17 +51,17 @@ vuint16m1x6_t test_vlseg6e16_v_u16m1x6_tu(vuint16m1x6_t vd, const uint16_t *rs1, } vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf4x6_tum(vm, vd, rs1, vl); } vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf2x6_tum(vm, vd, rs1, vl); } vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16m1x6_tum(vm, vd, rs1, vl); } @@ -96,19 +96,17 @@ vuint16m1x6_t test_vlseg6e16_v_u16m1x6_tum(vbool16_t vm, vuint16m1x6_t vd, } vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf4x6_tumu(vm, vd, rs1, vl); } vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf2x6_tumu(vm, vd, rs1, vl); } vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16m1x6_tumu(vm, vd, rs1, vl); } @@ -143,17 +141,17 @@ vuint16m1x6_t test_vlseg6e16_v_u16m1x6_tumu(vbool16_t vm, vuint16m1x6_t vd, } vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf4x6_mu(vm, vd, rs1, vl); } vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf2x6_mu(vm, vd, rs1, vl); } vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16m1x6_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlseg6e16ff.c b/auto-generated/policy_funcs/api-testing/vlseg6e16ff.c index a0631a4e1..45b439a20 100644 --- a/auto-generated/policy_funcs/api-testing/vlseg6e16ff.c +++ b/auto-generated/policy_funcs/api-testing/vlseg6e16ff.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf4x6_tu(vd, rs1, new_vl, vl); } vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf2x6_tu(vd, rs1, new_vl, vl); } vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16m1x6_tu(vd, rs1, new_vl, vl); } @@ -60,20 +60,20 @@ vuint16m1x6_t test_vlseg6e16ff_v_u16m1x6_tu(vuint16m1x6_t vd, vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf4x6_tum(vm, vd, rs1, new_vl, vl); } vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf2x6_tum(vm, vd, rs1, new_vl, vl); } vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16m1x6_tum(vm, vd, rs1, new_vl, vl); } @@ -116,20 +116,20 @@ vuint16m1x6_t test_vlseg6e16ff_v_u16m1x6_tum(vbool16_t vm, vuint16m1x6_t vd, vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf4x6_tumu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf2x6_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16m1x6_tumu(vm, vd, rs1, new_vl, vl); } @@ -171,19 +171,19 @@ vuint16m1x6_t test_vlseg6e16ff_v_u16m1x6_tumu(vbool16_t vm, vuint16m1x6_t vd, } vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf4x6_mu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf2x6_mu(vm, vd, rs1, new_vl, vl); } vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16m1x6_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlseg7e16.c b/auto-generated/policy_funcs/api-testing/vlseg7e16.c index a756ea85e..a69ba2294 100644 --- a/auto-generated/policy_funcs/api-testing/vlseg7e16.c +++ b/auto-generated/policy_funcs/api-testing/vlseg7e16.c @@ -6,17 +6,17 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf4x7_tu(vd, rs1, vl); } vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf2x7_tu(vd, rs1, vl); } vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16m1x7_tu(vd, rs1, vl); } @@ -51,17 +51,17 @@ vuint16m1x7_t test_vlseg7e16_v_u16m1x7_tu(vuint16m1x7_t vd, const uint16_t *rs1, } vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf4x7_tum(vm, vd, rs1, vl); } vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf2x7_tum(vm, vd, rs1, vl); } vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16m1x7_tum(vm, vd, rs1, vl); } @@ -96,19 +96,17 @@ vuint16m1x7_t test_vlseg7e16_v_u16m1x7_tum(vbool16_t vm, vuint16m1x7_t vd, } vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf4x7_tumu(vm, vd, rs1, vl); } vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf2x7_tumu(vm, vd, rs1, vl); } vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16m1x7_tumu(vm, vd, rs1, vl); } @@ -143,17 +141,17 @@ vuint16m1x7_t test_vlseg7e16_v_u16m1x7_tumu(vbool16_t vm, vuint16m1x7_t vd, } vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf4x7_mu(vm, vd, rs1, vl); } vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf2x7_mu(vm, vd, rs1, vl); } vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16m1x7_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlseg7e16ff.c b/auto-generated/policy_funcs/api-testing/vlseg7e16ff.c index a1d42c229..80edd7fa5 100644 --- a/auto-generated/policy_funcs/api-testing/vlseg7e16ff.c +++ b/auto-generated/policy_funcs/api-testing/vlseg7e16ff.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf4x7_tu(vd, rs1, new_vl, vl); } vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf2x7_tu(vd, rs1, new_vl, vl); } vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16m1x7_tu(vd, rs1, new_vl, vl); } @@ -60,20 +60,20 @@ vuint16m1x7_t test_vlseg7e16ff_v_u16m1x7_tu(vuint16m1x7_t vd, vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf4x7_tum(vm, vd, rs1, new_vl, vl); } vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf2x7_tum(vm, vd, rs1, new_vl, vl); } vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16m1x7_tum(vm, vd, rs1, new_vl, vl); } @@ -116,20 +116,20 @@ vuint16m1x7_t test_vlseg7e16ff_v_u16m1x7_tum(vbool16_t vm, vuint16m1x7_t vd, vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf4x7_tumu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf2x7_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16m1x7_tumu(vm, vd, rs1, new_vl, vl); } @@ -171,19 +171,19 @@ vuint16m1x7_t test_vlseg7e16ff_v_u16m1x7_tumu(vbool16_t vm, vuint16m1x7_t vd, } vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf4x7_mu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf2x7_mu(vm, vd, rs1, new_vl, vl); } vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16m1x7_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlseg8e16.c b/auto-generated/policy_funcs/api-testing/vlseg8e16.c index 2c3611d31..1005e9914 100644 --- a/auto-generated/policy_funcs/api-testing/vlseg8e16.c +++ b/auto-generated/policy_funcs/api-testing/vlseg8e16.c @@ -6,17 +6,17 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf4x8_tu(vd, rs1, vl); } vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf2x8_tu(vd, rs1, vl); } vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16m1x8_tu(vd, rs1, vl); } @@ -51,17 +51,17 @@ vuint16m1x8_t test_vlseg8e16_v_u16m1x8_tu(vuint16m1x8_t vd, const uint16_t *rs1, } vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf4x8_tum(vm, vd, rs1, vl); } vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf2x8_tum(vm, vd, rs1, vl); } vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16m1x8_tum(vm, vd, rs1, vl); } @@ -96,19 +96,17 @@ vuint16m1x8_t test_vlseg8e16_v_u16m1x8_tum(vbool16_t vm, vuint16m1x8_t vd, } vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf4x8_tumu(vm, vd, rs1, vl); } vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf2x8_tumu(vm, vd, rs1, vl); } vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16m1x8_tumu(vm, vd, rs1, vl); } @@ -143,17 +141,17 @@ vuint16m1x8_t test_vlseg8e16_v_u16m1x8_tumu(vbool16_t vm, vuint16m1x8_t vd, } vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf4x8_mu(vm, vd, rs1, vl); } vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf2x8_mu(vm, vd, rs1, vl); } vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16m1x8_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlseg8e16ff.c b/auto-generated/policy_funcs/api-testing/vlseg8e16ff.c index 813d786aa..1ab59e941 100644 --- a/auto-generated/policy_funcs/api-testing/vlseg8e16ff.c +++ b/auto-generated/policy_funcs/api-testing/vlseg8e16ff.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf4x8_tu(vd, rs1, new_vl, vl); } vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf2x8_tu(vd, rs1, new_vl, vl); } vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16m1x8_tu(vd, rs1, new_vl, vl); } @@ -60,20 +60,20 @@ vuint16m1x8_t test_vlseg8e16ff_v_u16m1x8_tu(vuint16m1x8_t vd, vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf4x8_tum(vm, vd, rs1, new_vl, vl); } vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf2x8_tum(vm, vd, rs1, new_vl, vl); } vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16m1x8_tum(vm, vd, rs1, new_vl, vl); } @@ -116,20 +116,20 @@ vuint16m1x8_t test_vlseg8e16ff_v_u16m1x8_tum(vbool16_t vm, vuint16m1x8_t vd, vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf4x8_tumu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf2x8_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16m1x8_tumu(vm, vd, rs1, new_vl, vl); } @@ -171,19 +171,19 @@ vuint16m1x8_t test_vlseg8e16ff_v_u16m1x8_tumu(vbool16_t vm, vuint16m1x8_t vd, } vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf4x8_mu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf2x8_mu(vm, vd, rs1, new_vl, vl); } vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16m1x8_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlsseg2e16.c b/auto-generated/policy_funcs/api-testing/vlsseg2e16.c index cd9463b5b..98d7305ed 100644 --- a/auto-generated/policy_funcs/api-testing/vlsseg2e16.c +++ b/auto-generated/policy_funcs/api-testing/vlsseg2e16.c @@ -6,31 +6,31 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf4x2_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf2x2_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m1x2_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m2x2_tu(vd, rs1, rs2, vl); } vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m4x2_tu(vd, rs1, rs2, vl); } @@ -93,32 +93,32 @@ vuint16m4x2_t test_vlsseg2e16_v_u16m4x2_tu(vuint16m4x2_t vd, } vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg2e16_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg2e16_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg2e16_v_f16m4x2_tum(vm, vd, rs1, rs2, vl); } @@ -184,32 +184,32 @@ vuint16m4x2_t test_vlsseg2e16_v_u16m4x2_tum(vbool4_t vm, vuint16m4x2_t vd, vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m4x2_tumu(vm, vd, rs1, rs2, vl); } @@ -275,31 +275,31 @@ vuint16m4x2_t test_vlsseg2e16_v_u16m4x2_tumu(vbool4_t vm, vuint16m4x2_t vd, } vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m4x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlsseg3e16.c b/auto-generated/policy_funcs/api-testing/vlsseg3e16.c index 8a40e0435..767074e2b 100644 --- a/auto-generated/policy_funcs/api-testing/vlsseg3e16.c +++ b/auto-generated/policy_funcs/api-testing/vlsseg3e16.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf4x3_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf2x3_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m1x3_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -76,26 +76,26 @@ vuint16m2x3_t test_vlsseg3e16_v_u16m2x3_tu(vuint16m2x3_t vd, } vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg3e16_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg3e16_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -149,26 +149,26 @@ vuint16m2x3_t test_vlsseg3e16_v_u16m2x3_tum(vbool8_t vm, vuint16m2x3_t vd, vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -222,25 +222,25 @@ vuint16m2x3_t test_vlsseg3e16_v_u16m2x3_tumu(vbool8_t vm, vuint16m2x3_t vd, } vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlsseg4e16.c b/auto-generated/policy_funcs/api-testing/vlsseg4e16.c index 62521c035..5f14492db 100644 --- a/auto-generated/policy_funcs/api-testing/vlsseg4e16.c +++ b/auto-generated/policy_funcs/api-testing/vlsseg4e16.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf4x4_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf2x4_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m1x4_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -76,26 +76,26 @@ vuint16m2x4_t test_vlsseg4e16_v_u16m2x4_tu(vuint16m2x4_t vd, } vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg4e16_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg4e16_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -149,26 +149,26 @@ vuint16m2x4_t test_vlsseg4e16_v_u16m2x4_tum(vbool8_t vm, vuint16m2x4_t vd, vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -222,25 +222,25 @@ vuint16m2x4_t test_vlsseg4e16_v_u16m2x4_tumu(vbool8_t vm, vuint16m2x4_t vd, } vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlsseg5e16.c b/auto-generated/policy_funcs/api-testing/vlsseg5e16.c index 11ba2b28e..d982ff7ef 100644 --- a/auto-generated/policy_funcs/api-testing/vlsseg5e16.c +++ b/auto-generated/policy_funcs/api-testing/vlsseg5e16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf4x5_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf2x5_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -59,20 +59,20 @@ vuint16m1x5_t test_vlsseg5e16_v_u16m1x5_tu(vuint16m1x5_t vd, } vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg5e16_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -114,20 +114,20 @@ vuint16m1x5_t test_vlsseg5e16_v_u16m1x5_tum(vbool16_t vm, vuint16m1x5_t vd, vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -169,19 +169,19 @@ vuint16m1x5_t test_vlsseg5e16_v_u16m1x5_tumu(vbool16_t vm, vuint16m1x5_t vd, } vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlsseg6e16.c b/auto-generated/policy_funcs/api-testing/vlsseg6e16.c index 1bec7f68c..cc768f0aa 100644 --- a/auto-generated/policy_funcs/api-testing/vlsseg6e16.c +++ b/auto-generated/policy_funcs/api-testing/vlsseg6e16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf4x6_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf2x6_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -59,20 +59,20 @@ vuint16m1x6_t test_vlsseg6e16_v_u16m1x6_tu(vuint16m1x6_t vd, } vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg6e16_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -114,20 +114,20 @@ vuint16m1x6_t test_vlsseg6e16_v_u16m1x6_tum(vbool16_t vm, vuint16m1x6_t vd, vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -169,19 +169,19 @@ vuint16m1x6_t test_vlsseg6e16_v_u16m1x6_tumu(vbool16_t vm, vuint16m1x6_t vd, } vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlsseg7e16.c b/auto-generated/policy_funcs/api-testing/vlsseg7e16.c index 8f0e2ca31..763e1b115 100644 --- a/auto-generated/policy_funcs/api-testing/vlsseg7e16.c +++ b/auto-generated/policy_funcs/api-testing/vlsseg7e16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf4x7_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf2x7_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -59,20 +59,20 @@ vuint16m1x7_t test_vlsseg7e16_v_u16m1x7_tu(vuint16m1x7_t vd, } vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg7e16_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -114,20 +114,20 @@ vuint16m1x7_t test_vlsseg7e16_v_u16m1x7_tum(vbool16_t vm, vuint16m1x7_t vd, vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -169,19 +169,19 @@ vuint16m1x7_t test_vlsseg7e16_v_u16m1x7_tumu(vbool16_t vm, vuint16m1x7_t vd, } vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vlsseg8e16.c b/auto-generated/policy_funcs/api-testing/vlsseg8e16.c index 7ed14f90e..0b1f07c35 100644 --- a/auto-generated/policy_funcs/api-testing/vlsseg8e16.c +++ b/auto-generated/policy_funcs/api-testing/vlsseg8e16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf4x8_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf2x8_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -59,20 +59,20 @@ vuint16m1x8_t test_vlsseg8e16_v_u16m1x8_tu(vuint16m1x8_t vd, } vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg8e16_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -114,20 +114,20 @@ vuint16m1x8_t test_vlsseg8e16_v_u16m1x8_tum(vbool16_t vm, vuint16m1x8_t vd, vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -169,19 +169,19 @@ vuint16m1x8_t test_vlsseg8e16_v_u16m1x8_tumu(vbool16_t vm, vuint16m1x8_t vd, } vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxei16.c b/auto-generated/policy_funcs/api-testing/vluxei16.c index 6c0be2f90..5c1ba8982 100644 --- a/auto-generated/policy_funcs/api-testing/vluxei16.c +++ b/auto-generated/policy_funcs/api-testing/vluxei16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei16_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vluxei16_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vluxei16_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vluxei16_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vluxei16_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m2_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vluxei16_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m4_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, +vfloat16m8_t test_vluxei16_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m8_tu(vd, rs1, rs2, vl); } @@ -291,37 +291,37 @@ vuint64m8_t test_vluxei16_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, } vfloat16mf4_t test_vluxei16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint16mf4_t rs2, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint16mf2_t rs2, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint16m1_t rs2, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m1_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint16m2_t rs2, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m2_tum(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint16m4_t rs2, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m4_tum(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vluxei16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint16m8_t rs2, + const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m8_tum(vm, vd, rs1, rs2, vl); } @@ -630,37 +630,37 @@ vuint64m8_t test_vluxei16_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vluxei16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, - vuint16mf4_t rs2, size_t vl) { + const _Float16 *rs1, vuint16mf4_t rs2, + size_t vl) { return __riscv_vluxei16_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, - vuint16mf2_t rs2, size_t vl) { + const _Float16 *rs1, vuint16mf2_t rs2, + size_t vl) { return __riscv_vluxei16_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint16m1_t rs2, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint16m2_t rs2, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint16m4_t rs2, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vluxei16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint16m8_t rs2, + const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m8_tumu(vm, vd, rs1, rs2, vl); } @@ -972,37 +972,37 @@ vuint64m8_t test_vluxei16_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vluxei16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint16mf4_t rs2, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint16mf2_t rs2, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint16m1_t rs2, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m1_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint16m2_t rs2, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m2_mu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint16m4_t rs2, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m4_mu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vluxei16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint16m8_t rs2, + const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxei32.c b/auto-generated/policy_funcs/api-testing/vluxei32.c index 67252c055..519eb79fa 100644 --- a/auto-generated/policy_funcs/api-testing/vluxei32.c +++ b/auto-generated/policy_funcs/api-testing/vluxei32.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei32_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vluxei32_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vluxei32_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vluxei32_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vluxei32_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m2_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vluxei32_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m4_tu(vd, rs1, rs2, vl); } @@ -266,31 +266,31 @@ vuint64m8_t test_vluxei32_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, } vfloat16mf4_t test_vluxei32_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint32mf2_t rs2, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei32_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint32m1_t rs2, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei32_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint32m2_t rs2, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m1_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei32_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint32m4_t rs2, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m2_tum(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei32_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint32m8_t rs2, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m4_tum(vm, vd, rs1, rs2, vl); } @@ -576,31 +576,31 @@ vuint64m8_t test_vluxei32_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vluxei32_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, - vuint32mf2_t rs2, size_t vl) { + const _Float16 *rs1, vuint32mf2_t rs2, + size_t vl) { return __riscv_vluxei32_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei32_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint32m1_t rs2, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei32_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint32m2_t rs2, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei32_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint32m4_t rs2, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei32_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint32m8_t rs2, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m4_tumu(vm, vd, rs1, rs2, vl); } @@ -888,31 +888,31 @@ vuint64m8_t test_vluxei32_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vluxei32_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint32mf2_t rs2, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei32_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint32m1_t rs2, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei32_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint32m2_t rs2, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m1_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei32_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint32m4_t rs2, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m2_mu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei32_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint32m8_t rs2, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxei64.c b/auto-generated/policy_funcs/api-testing/vluxei64.c index 40989846f..05512c443 100644 --- a/auto-generated/policy_funcs/api-testing/vluxei64.c +++ b/auto-generated/policy_funcs/api-testing/vluxei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei64_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vluxei64_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vluxei64_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vluxei64_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vluxei64_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m2_tu(vd, rs1, rs2, vl); } @@ -226,25 +226,25 @@ vuint64m8_t test_vluxei64_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, } vfloat16mf4_t test_vluxei64_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint64m1_t rs2, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei64_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint64m2_t rs2, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei64_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint64m4_t rs2, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m1_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei64_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint64m8_t rs2, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m2_tum(vm, vd, rs1, rs2, vl); } @@ -489,25 +489,25 @@ vuint64m8_t test_vluxei64_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vluxei64_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint64m1_t rs2, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei64_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint64m2_t rs2, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei64_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint64m4_t rs2, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei64_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint64m8_t rs2, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } @@ -753,25 +753,25 @@ vuint64m8_t test_vluxei64_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vluxei64_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint64m1_t rs2, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei64_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint64m2_t rs2, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei64_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint64m4_t rs2, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m1_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei64_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint64m8_t rs2, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxei8.c b/auto-generated/policy_funcs/api-testing/vluxei8.c index 40d97ceba..c9e416267 100644 --- a/auto-generated/policy_funcs/api-testing/vluxei8.c +++ b/auto-generated/policy_funcs/api-testing/vluxei8.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei8_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vluxei8_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vluxei8_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vluxei8_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vluxei8_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m2_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vluxei8_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m4_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, +vfloat16m8_t test_vluxei8_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m8_tu(vd, rs1, rs2, vl); } @@ -301,37 +301,37 @@ vuint64m8_t test_vluxei8_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, } vfloat16mf4_t test_vluxei8_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint8mf8_t rs2, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei8_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint8mf4_t rs2, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei8_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint8mf2_t rs2, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m1_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei8_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint8m1_t rs2, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m2_tum(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei8_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint8m2_t rs2, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m4_tum(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vluxei8_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint8m4_t rs2, + const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m8_tum(vm, vd, rs1, rs2, vl); } @@ -651,37 +651,37 @@ vuint64m8_t test_vluxei8_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vluxei8_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint8mf8_t rs2, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei8_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint8mf4_t rs2, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei8_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint8mf2_t rs2, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei8_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint8m1_t rs2, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei8_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint8m2_t rs2, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vluxei8_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint8m4_t rs2, + const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m8_tumu(vm, vd, rs1, rs2, vl); } @@ -1001,37 +1001,37 @@ vuint64m8_t test_vluxei8_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vluxei8_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint8mf8_t rs2, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei8_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint8mf4_t rs2, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei8_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint8mf2_t rs2, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m1_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei8_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint8m1_t rs2, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m2_mu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei8_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint8m2_t rs2, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m4_mu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vluxei8_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint8m4_t rs2, + const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg2ei16.c b/auto-generated/policy_funcs/api-testing/vluxseg2ei16.c index 1a10bd21e..b683d04c8 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg2ei16.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg2ei16.c @@ -6,31 +6,31 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf4x2_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf2x2_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m1x2_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m2x2_tu(vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m4x2_tu(vd, rs1, rs2, vl); } @@ -277,32 +277,32 @@ vuint64m4x2_t test_vluxseg2ei16_v_u64m4x2_tu(vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m4x2_tum(vm, vd, rs1, rs2, vl); } @@ -568,32 +568,32 @@ vuint64m4x2_t test_vluxseg2ei16_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m4x2_tumu(vm, vd, rs1, rs2, vl); } @@ -862,32 +862,32 @@ vuint64m4x2_t test_vluxseg2ei16_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m4x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg2ei32.c b/auto-generated/policy_funcs/api-testing/vluxseg2ei32.c index 8034d71e8..98c74f9a6 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg2ei32.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg2ei32.c @@ -6,31 +6,31 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf4x2_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf2x2_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m1x2_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m2x2_tu(vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m4x2_tu(vd, rs1, rs2, vl); } @@ -267,32 +267,32 @@ vuint64m4x2_t test_vluxseg2ei32_v_u64m4x2_tu(vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m4x2_tum(vm, vd, rs1, rs2, vl); } @@ -546,32 +546,32 @@ vuint64m4x2_t test_vluxseg2ei32_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m4x2_tumu(vm, vd, rs1, rs2, vl); } @@ -828,32 +828,32 @@ vuint64m4x2_t test_vluxseg2ei32_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m4x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg2ei64.c b/auto-generated/policy_funcs/api-testing/vluxseg2ei64.c index 72573bf53..9b8869dd7 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg2ei64.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg2ei64.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf4x2_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf2x2_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m1x2_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m2x2_tu(vd, rs1, rs2, vl); } @@ -240,26 +240,26 @@ vuint64m4x2_t test_vluxseg2ei64_v_u64m4x2_tu(vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } @@ -489,26 +489,26 @@ vuint64m4x2_t test_vluxseg2ei64_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } @@ -741,26 +741,26 @@ vuint64m4x2_t test_vluxseg2ei64_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg2ei8.c b/auto-generated/policy_funcs/api-testing/vluxseg2ei8.c index 3c348a5cd..5bc928f03 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg2ei8.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg2ei8.c @@ -6,31 +6,31 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf4x2_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf2x2_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m1x2_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m2x2_tu(vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m4x2_tu(vd, rs1, rs2, vl); } @@ -277,32 +277,32 @@ vuint64m4x2_t test_vluxseg2ei8_v_u64m4x2_tu(vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m4x2_tum(vm, vd, rs1, rs2, vl); } @@ -568,32 +568,32 @@ vuint64m4x2_t test_vluxseg2ei8_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m4x2_tumu(vm, vd, rs1, rs2, vl); } @@ -858,31 +858,31 @@ vuint64m4x2_t test_vluxseg2ei8_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, } vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m4x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg3ei16.c b/auto-generated/policy_funcs/api-testing/vluxseg3ei16.c index 6cb6e845b..c386ec584 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg3ei16.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg3ei16.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf4x3_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf2x3_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m1x3_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x3_t test_vluxseg3ei16_v_u64m2x3_tu(vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x3_t test_vluxseg3ei16_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -669,26 +669,26 @@ vuint64m2x3_t test_vluxseg3ei16_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg3ei32.c b/auto-generated/policy_funcs/api-testing/vluxseg3ei32.c index d35c5b0fc..7615be4bd 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg3ei32.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg3ei32.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf4x3_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf2x3_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m1x3_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x3_t test_vluxseg3ei32_v_u64m2x3_tu(vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x3_t test_vluxseg3ei32_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -669,26 +669,26 @@ vuint64m2x3_t test_vluxseg3ei32_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg3ei64.c b/auto-generated/policy_funcs/api-testing/vluxseg3ei64.c index dc9dff252..f9339174c 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg3ei64.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg3ei64.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf4x3_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf2x3_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m1x3_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -206,26 +206,26 @@ vuint64m2x3_t test_vluxseg3ei64_v_u64m2x3_tu(vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -419,26 +419,26 @@ vuint64m2x3_t test_vluxseg3ei64_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -635,26 +635,26 @@ vuint64m2x3_t test_vluxseg3ei64_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg3ei8.c b/auto-generated/policy_funcs/api-testing/vluxseg3ei8.c index fcbf921c3..9b41186c6 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg3ei8.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg3ei8.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf4x3_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf2x3_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m1x3_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x3_t test_vluxseg3ei8_v_u64m2x3_tu(vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x3_t test_vluxseg3ei8_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -665,25 +665,25 @@ vuint64m2x3_t test_vluxseg3ei8_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, } vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg4ei16.c b/auto-generated/policy_funcs/api-testing/vluxseg4ei16.c index 83f8a88ba..7c676807b 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg4ei16.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg4ei16.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf4x4_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf2x4_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m1x4_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x4_t test_vluxseg4ei16_v_u64m2x4_tu(vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x4_t test_vluxseg4ei16_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -669,26 +669,26 @@ vuint64m2x4_t test_vluxseg4ei16_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg4ei32.c b/auto-generated/policy_funcs/api-testing/vluxseg4ei32.c index 2d5efb7c0..31726153d 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg4ei32.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg4ei32.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf4x4_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf2x4_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m1x4_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x4_t test_vluxseg4ei32_v_u64m2x4_tu(vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x4_t test_vluxseg4ei32_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -669,26 +669,26 @@ vuint64m2x4_t test_vluxseg4ei32_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg4ei64.c b/auto-generated/policy_funcs/api-testing/vluxseg4ei64.c index f7c620e67..2b94752a6 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg4ei64.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg4ei64.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf4x4_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf2x4_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m1x4_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -206,26 +206,26 @@ vuint64m2x4_t test_vluxseg4ei64_v_u64m2x4_tu(vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -419,26 +419,26 @@ vuint64m2x4_t test_vluxseg4ei64_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -635,26 +635,26 @@ vuint64m2x4_t test_vluxseg4ei64_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg4ei8.c b/auto-generated/policy_funcs/api-testing/vluxseg4ei8.c index c09f70ed0..215d8f038 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg4ei8.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg4ei8.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf4x4_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf2x4_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m1x4_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x4_t test_vluxseg4ei8_v_u64m2x4_tu(vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x4_t test_vluxseg4ei8_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -665,25 +665,25 @@ vuint64m2x4_t test_vluxseg4ei8_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, } vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg5ei16.c b/auto-generated/policy_funcs/api-testing/vluxseg5ei16.c index 76c9e2a87..d0f514845 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg5ei16.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg5ei16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf4x5_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf2x5_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x5_t test_vluxseg5ei16_v_u64m1x5_tu(vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x5_t test_vluxseg5ei16_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x5_t test_vluxseg5ei16_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg5ei32.c b/auto-generated/policy_funcs/api-testing/vluxseg5ei32.c index 8d6034465..41affd938 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg5ei32.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg5ei32.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf4x5_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf2x5_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x5_t test_vluxseg5ei32_v_u64m1x5_tu(vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x5_t test_vluxseg5ei32_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x5_t test_vluxseg5ei32_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg5ei64.c b/auto-generated/policy_funcs/api-testing/vluxseg5ei64.c index 077c13a0d..48cfde463 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg5ei64.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg5ei64.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf4x5_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf2x5_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x5_t test_vluxseg5ei64_v_u64m1x5_tu(vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x5_t test_vluxseg5ei64_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x5_t test_vluxseg5ei64_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg5ei8.c b/auto-generated/policy_funcs/api-testing/vluxseg5ei8.c index e407be61b..55b157daa 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg5ei8.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg5ei8.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf4x5_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf2x5_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x5_t test_vluxseg5ei8_v_u64m1x5_tu(vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x5_t test_vluxseg5ei8_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -472,19 +472,19 @@ vuint64m1x5_t test_vluxseg5ei8_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, } vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg6ei16.c b/auto-generated/policy_funcs/api-testing/vluxseg6ei16.c index 243a10e94..f1ec5b63a 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg6ei16.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg6ei16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf4x6_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf2x6_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x6_t test_vluxseg6ei16_v_u64m1x6_tu(vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x6_t test_vluxseg6ei16_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x6_t test_vluxseg6ei16_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg6ei32.c b/auto-generated/policy_funcs/api-testing/vluxseg6ei32.c index 700b73628..14a833d8f 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg6ei32.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg6ei32.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf4x6_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf2x6_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x6_t test_vluxseg6ei32_v_u64m1x6_tu(vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x6_t test_vluxseg6ei32_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x6_t test_vluxseg6ei32_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg6ei64.c b/auto-generated/policy_funcs/api-testing/vluxseg6ei64.c index ff44cd370..42ab638f8 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg6ei64.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg6ei64.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf4x6_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf2x6_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x6_t test_vluxseg6ei64_v_u64m1x6_tu(vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x6_t test_vluxseg6ei64_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x6_t test_vluxseg6ei64_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg6ei8.c b/auto-generated/policy_funcs/api-testing/vluxseg6ei8.c index f640f17b3..950d2960c 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg6ei8.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg6ei8.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf4x6_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf2x6_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x6_t test_vluxseg6ei8_v_u64m1x6_tu(vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x6_t test_vluxseg6ei8_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -472,19 +472,19 @@ vuint64m1x6_t test_vluxseg6ei8_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, } vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg7ei16.c b/auto-generated/policy_funcs/api-testing/vluxseg7ei16.c index 961b49823..17c4bebdb 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg7ei16.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg7ei16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf4x7_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf2x7_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x7_t test_vluxseg7ei16_v_u64m1x7_tu(vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x7_t test_vluxseg7ei16_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x7_t test_vluxseg7ei16_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg7ei32.c b/auto-generated/policy_funcs/api-testing/vluxseg7ei32.c index 95dab2c89..84086d840 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg7ei32.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg7ei32.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf4x7_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf2x7_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x7_t test_vluxseg7ei32_v_u64m1x7_tu(vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x7_t test_vluxseg7ei32_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x7_t test_vluxseg7ei32_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg7ei64.c b/auto-generated/policy_funcs/api-testing/vluxseg7ei64.c index 02ebdaa56..d0215d166 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg7ei64.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg7ei64.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf4x7_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf2x7_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x7_t test_vluxseg7ei64_v_u64m1x7_tu(vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x7_t test_vluxseg7ei64_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x7_t test_vluxseg7ei64_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg7ei8.c b/auto-generated/policy_funcs/api-testing/vluxseg7ei8.c index 0e0441571..b21ee3af7 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg7ei8.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg7ei8.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf4x7_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf2x7_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x7_t test_vluxseg7ei8_v_u64m1x7_tu(vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x7_t test_vluxseg7ei8_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -472,19 +472,19 @@ vuint64m1x7_t test_vluxseg7ei8_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, } vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg8ei16.c b/auto-generated/policy_funcs/api-testing/vluxseg8ei16.c index 914693459..cbf805d16 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg8ei16.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg8ei16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf4x8_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf2x8_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x8_t test_vluxseg8ei16_v_u64m1x8_tu(vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x8_t test_vluxseg8ei16_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x8_t test_vluxseg8ei16_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg8ei32.c b/auto-generated/policy_funcs/api-testing/vluxseg8ei32.c index 659b10ad7..28b002e1b 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg8ei32.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg8ei32.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf4x8_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf2x8_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x8_t test_vluxseg8ei32_v_u64m1x8_tu(vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x8_t test_vluxseg8ei32_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x8_t test_vluxseg8ei32_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg8ei64.c b/auto-generated/policy_funcs/api-testing/vluxseg8ei64.c index 2cb60006e..178dd12dd 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg8ei64.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg8ei64.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf4x8_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf2x8_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x8_t test_vluxseg8ei64_v_u64m1x8_tu(vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x8_t test_vluxseg8ei64_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x8_t test_vluxseg8ei64_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/api-testing/vluxseg8ei8.c b/auto-generated/policy_funcs/api-testing/vluxseg8ei8.c index 4c9f723a6..ffaa45e9a 100644 --- a/auto-generated/policy_funcs/api-testing/vluxseg8ei8.c +++ b/auto-generated/policy_funcs/api-testing/vluxseg8ei8.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf4x8_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf2x8_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x8_t test_vluxseg8ei8_v_u64m1x8_tu(vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x8_t test_vluxseg8ei8_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -472,19 +472,19 @@ vuint64m1x8_t test_vluxseg8ei8_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, } vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vle16.c b/auto-generated/policy_funcs/gnu-api-tests/vle16.c index f609bc9ae..61f389d47 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vle16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vle16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vle16_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4_t test_vle16_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf4_tu(vd, rs1, vl); } -vfloat16mf2_t test_vle16_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2_t test_vle16_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf2_tu(vd, rs1, vl); } -vfloat16m1_t test_vle16_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1_t test_vle16_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m1_tu(vd, rs1, vl); } -vfloat16m2_t test_vle16_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2_t test_vle16_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m2_tu(vd, rs1, vl); } -vfloat16m4_t test_vle16_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m4_t test_vle16_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m4_tu(vd, rs1, vl); } -vfloat16m8_t test_vle16_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, size_t vl) { +vfloat16m8_t test_vle16_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m8_tu(vd, rs1, vl); } @@ -79,27 +79,27 @@ vuint16m8_t test_vle16_v_u16m8_tu(vuint16m8_t vd, const uint16_t *rs1, size_t vl return __riscv_vle16_v_u16m8_tu(vd, rs1, vl); } -vfloat16mf4_t test_vle16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4_t test_vle16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf4_tum(vm, vd, rs1, vl); } -vfloat16mf2_t test_vle16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2_t test_vle16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf2_tum(vm, vd, rs1, vl); } -vfloat16m1_t test_vle16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1_t test_vle16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m1_tum(vm, vd, rs1, vl); } -vfloat16m2_t test_vle16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2_t test_vle16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m2_tum(vm, vd, rs1, vl); } -vfloat16m4_t test_vle16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m4_t test_vle16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m4_tum(vm, vd, rs1, vl); } -vfloat16m8_t test_vle16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, size_t vl) { +vfloat16m8_t test_vle16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m8_tum(vm, vd, rs1, vl); } @@ -151,27 +151,27 @@ vuint16m8_t test_vle16_v_u16m8_tum(vbool2_t vm, vuint16m8_t vd, const uint16_t * return __riscv_vle16_v_u16m8_tum(vm, vd, rs1, vl); } -vfloat16mf4_t test_vle16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4_t test_vle16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf4_tumu(vm, vd, rs1, vl); } -vfloat16mf2_t test_vle16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2_t test_vle16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf2_tumu(vm, vd, rs1, vl); } -vfloat16m1_t test_vle16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1_t test_vle16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m1_tumu(vm, vd, rs1, vl); } -vfloat16m2_t test_vle16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2_t test_vle16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m2_tumu(vm, vd, rs1, vl); } -vfloat16m4_t test_vle16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m4_t test_vle16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m4_tumu(vm, vd, rs1, vl); } -vfloat16m8_t test_vle16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, size_t vl) { +vfloat16m8_t test_vle16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m8_tumu(vm, vd, rs1, vl); } @@ -223,27 +223,27 @@ vuint16m8_t test_vle16_v_u16m8_tumu(vbool2_t vm, vuint16m8_t vd, const uint16_t return __riscv_vle16_v_u16m8_tumu(vm, vd, rs1, vl); } -vfloat16mf4_t test_vle16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4_t test_vle16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf4_mu(vm, vd, rs1, vl); } -vfloat16mf2_t test_vle16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2_t test_vle16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16mf2_mu(vm, vd, rs1, vl); } -vfloat16m1_t test_vle16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1_t test_vle16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m1_mu(vm, vd, rs1, vl); } -vfloat16m2_t test_vle16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2_t test_vle16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m2_mu(vm, vd, rs1, vl); } -vfloat16m4_t test_vle16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m4_t test_vle16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m4_mu(vm, vd, rs1, vl); } -vfloat16m8_t test_vle16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, size_t vl) { +vfloat16m8_t test_vle16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_v_f16m8_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vle16ff.c b/auto-generated/policy_funcs/gnu-api-tests/vle16ff.c index 666664a37..7801ecfa0 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vle16ff.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vle16ff.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vle16ff_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4_t test_vle16ff_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf4_tu(vd, rs1, new_vl, vl); } -vfloat16mf2_t test_vle16ff_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2_t test_vle16ff_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf2_tu(vd, rs1, new_vl, vl); } -vfloat16m1_t test_vle16ff_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1_t test_vle16ff_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m1_tu(vd, rs1, new_vl, vl); } -vfloat16m2_t test_vle16ff_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2_t test_vle16ff_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m2_tu(vd, rs1, new_vl, vl); } -vfloat16m4_t test_vle16ff_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4_t test_vle16ff_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m4_tu(vd, rs1, new_vl, vl); } -vfloat16m8_t test_vle16ff_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m8_t test_vle16ff_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m8_tu(vd, rs1, new_vl, vl); } @@ -79,27 +79,27 @@ vuint16m8_t test_vle16ff_v_u16m8_tu(vuint16m8_t vd, const uint16_t *rs1, size_t return __riscv_vle16ff_v_u16m8_tu(vd, rs1, new_vl, vl); } -vfloat16mf4_t test_vle16ff_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4_t test_vle16ff_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf4_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf2_t test_vle16ff_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2_t test_vle16ff_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf2_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m1_t test_vle16ff_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1_t test_vle16ff_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m1_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m2_t test_vle16ff_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2_t test_vle16ff_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m2_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m4_t test_vle16ff_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4_t test_vle16ff_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m4_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m8_t test_vle16ff_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m8_t test_vle16ff_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m8_tum(vm, vd, rs1, new_vl, vl); } @@ -151,27 +151,27 @@ vuint16m8_t test_vle16ff_v_u16m8_tum(vbool2_t vm, vuint16m8_t vd, const uint16_t return __riscv_vle16ff_v_u16m8_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf4_t test_vle16ff_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4_t test_vle16ff_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf4_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2_t test_vle16ff_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2_t test_vle16ff_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf2_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m1_t test_vle16ff_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1_t test_vle16ff_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m1_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m2_t test_vle16ff_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2_t test_vle16ff_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m2_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m4_t test_vle16ff_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4_t test_vle16ff_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m4_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m8_t test_vle16ff_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m8_t test_vle16ff_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m8_tumu(vm, vd, rs1, new_vl, vl); } @@ -223,27 +223,27 @@ vuint16m8_t test_vle16ff_v_u16m8_tumu(vbool2_t vm, vuint16m8_t vd, const uint16_ return __riscv_vle16ff_v_u16m8_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf4_t test_vle16ff_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4_t test_vle16ff_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf4_mu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2_t test_vle16ff_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2_t test_vle16ff_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16mf2_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m1_t test_vle16ff_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1_t test_vle16ff_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m1_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m2_t test_vle16ff_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2_t test_vle16ff_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m2_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m4_t test_vle16ff_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4_t test_vle16ff_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m4_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m8_t test_vle16ff_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m8_t test_vle16ff_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_v_f16m8_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxei16.c b/auto-generated/policy_funcs/gnu-api-tests/vloxei16.c index 3d07fdac3..e542d2f75 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxei16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxei16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei16_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei16_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei16_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vloxei16_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vloxei16_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m2_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vloxei16_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m4_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vloxei16_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m8_tu(vd, rs1, rs2, vl); } @@ -235,27 +235,27 @@ vuint64m8_t test_vloxei16_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, vuint1 return __riscv_vloxei16_v_u64m8_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vloxei16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m1_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vloxei16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vloxei16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vloxei16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m8_tum(vm, vd, rs1, rs2, vl); } @@ -463,27 +463,27 @@ vuint64m8_t test_vloxei16_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, const uint64_ return __riscv_vloxei16_v_u64m8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vloxei16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vloxei16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vloxei16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vloxei16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m8_tumu(vm, vd, rs1, rs2, vl); } @@ -691,27 +691,27 @@ vuint64m8_t test_vloxei16_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, const uint64 return __riscv_vloxei16_v_u64m8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vloxei16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m1_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vloxei16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vloxei16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vloxei16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_v_f16m8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxei32.c b/auto-generated/policy_funcs/gnu-api-tests/vloxei32.c index 027e5a006..58b0365ed 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxei32.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei32_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei32_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei32_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei32_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vloxei32_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m2_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vloxei32_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m4_tu(vd, rs1, rs2, vl); } @@ -215,23 +215,23 @@ vuint64m8_t test_vloxei32_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, vuint3 return __riscv_vloxei32_v_u64m8_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei32_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei32_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei32_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei32_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m1_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vloxei32_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vloxei32_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m4_tum(vm, vd, rs1, rs2, vl); } @@ -423,23 +423,23 @@ vuint64m8_t test_vloxei32_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, const uint64_ return __riscv_vloxei32_v_u64m8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei32_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei32_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei32_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei32_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vloxei32_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vloxei32_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m4_tumu(vm, vd, rs1, rs2, vl); } @@ -631,23 +631,23 @@ vuint64m8_t test_vloxei32_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, const uint64 return __riscv_vloxei32_v_u64m8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei32_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei32_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei32_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei32_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m1_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vloxei32_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vloxei32_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_v_f16m4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxei64.c b/auto-generated/policy_funcs/gnu-api-tests/vloxei64.c index 2a87437aa..f6165a2d6 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxei64.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei64_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei64_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei64_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vloxei64_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vloxei64_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m2_tu(vd, rs1, rs2, vl); } @@ -183,19 +183,19 @@ vuint64m8_t test_vloxei64_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, vuint6 return __riscv_vloxei64_v_u64m8_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei64_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei64_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei64_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vloxei64_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m1_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vloxei64_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m2_tum(vm, vd, rs1, rs2, vl); } @@ -359,19 +359,19 @@ vuint64m8_t test_vloxei64_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, const uint64_ return __riscv_vloxei64_v_u64m8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei64_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei64_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei64_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vloxei64_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vloxei64_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } @@ -535,19 +535,19 @@ vuint64m8_t test_vloxei64_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, const uint64 return __riscv_vloxei64_v_u64m8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei64_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei64_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei64_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vloxei64_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m1_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vloxei64_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_v_f16m2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxei8.c b/auto-generated/policy_funcs/gnu-api-tests/vloxei8.c index 9610cd498..5e50e0715 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxei8.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxei8.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei8_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei8_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei8_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei8_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vloxei8_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m2_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vloxei8_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m4_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vloxei8_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m8_tu(vd, rs1, rs2, vl); } @@ -243,27 +243,27 @@ vuint64m8_t test_vloxei8_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, vuint8m return __riscv_vloxei8_v_u64m8_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei8_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei8_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei8_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei8_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m1_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vloxei8_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vloxei8_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vloxei8_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m8_tum(vm, vd, rs1, rs2, vl); } @@ -479,27 +479,27 @@ vuint64m8_t test_vloxei8_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, const uint64_t return __riscv_vloxei8_v_u64m8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei8_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei8_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei8_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei8_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vloxei8_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vloxei8_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vloxei8_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m8_tumu(vm, vd, rs1, rs2, vl); } @@ -715,27 +715,27 @@ vuint64m8_t test_vloxei8_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, const uint64_ return __riscv_vloxei8_v_u64m8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei8_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei8_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei8_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei8_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m1_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vloxei8_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vloxei8_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vloxei8_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_v_f16m8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg2ei16.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg2ei16.c index 0d4eb3631..1115b60b2 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg2ei16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg2ei16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf2x2_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m1x2_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m2x2_tu(vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m4x2_tu(vd, rs1, rs2, vl); } @@ -199,23 +199,23 @@ vuint64m4x2_t test_vloxseg2ei16_v_u64m4x2_tu(vuint64m4x2_t vd, const uint64_t *r return __riscv_vloxseg2ei16_v_u64m4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m4x2_tum(vm, vd, rs1, rs2, vl); } @@ -391,23 +391,23 @@ vuint64m4x2_t test_vloxseg2ei16_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, co return __riscv_vloxseg2ei16_v_u64m4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m4x2_tumu(vm, vd, rs1, rs2, vl); } @@ -583,23 +583,23 @@ vuint64m4x2_t test_vloxseg2ei16_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, c return __riscv_vloxseg2ei16_v_u64m4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_v_f16m4x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg2ei32.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg2ei32.c index 0a6768ee4..8f7d07763 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg2ei32.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg2ei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf2x2_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m1x2_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m2x2_tu(vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m4x2_tu(vd, rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m4x2_t test_vloxseg2ei32_v_u64m4x2_tu(vuint64m4x2_t vd, const uint64_t *r return __riscv_vloxseg2ei32_v_u64m4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m4x2_tum(vm, vd, rs1, rs2, vl); } @@ -375,23 +375,23 @@ vuint64m4x2_t test_vloxseg2ei32_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, co return __riscv_vloxseg2ei32_v_u64m4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m4x2_tumu(vm, vd, rs1, rs2, vl); } @@ -559,23 +559,23 @@ vuint64m4x2_t test_vloxseg2ei32_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, c return __riscv_vloxseg2ei32_v_u64m4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_v_f16m4x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg2ei64.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg2ei64.c index be1e5a3b1..32f671557 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg2ei64.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg2ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf2x2_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m1x2_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m2x2_tu(vd, rs1, rs2, vl); } @@ -171,19 +171,19 @@ vuint64m4x2_t test_vloxseg2ei64_v_u64m4x2_tu(vuint64m4x2_t vd, const uint64_t *r return __riscv_vloxseg2ei64_v_u64m4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } @@ -335,19 +335,19 @@ vuint64m4x2_t test_vloxseg2ei64_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, co return __riscv_vloxseg2ei64_v_u64m4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } @@ -499,19 +499,19 @@ vuint64m4x2_t test_vloxseg2ei64_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, c return __riscv_vloxseg2ei64_v_u64m4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg2ei8.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg2ei8.c index 1f5fb9b9e..eefca3195 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg2ei8.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg2ei8.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf2x2_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m1x2_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m2x2_tu(vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m4x2_tu(vd, rs1, rs2, vl); } @@ -199,23 +199,23 @@ vuint64m4x2_t test_vloxseg2ei8_v_u64m4x2_tu(vuint64m4x2_t vd, const uint64_t *rs return __riscv_vloxseg2ei8_v_u64m4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m4x2_tum(vm, vd, rs1, rs2, vl); } @@ -391,23 +391,23 @@ vuint64m4x2_t test_vloxseg2ei8_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, con return __riscv_vloxseg2ei8_v_u64m4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m4x2_tumu(vm, vd, rs1, rs2, vl); } @@ -583,23 +583,23 @@ vuint64m4x2_t test_vloxseg2ei8_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, co return __riscv_vloxseg2ei8_v_u64m4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_v_f16m4x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg3ei16.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg3ei16.c index 67d64985c..f5a9601eb 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg3ei16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg3ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf4x3_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf2x3_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m1x3_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vloxseg3ei16_v_u64m2x3_tu(vuint64m2x3_t vd, const uint64_t *r return __riscv_vloxseg3ei16_v_u64m2x3_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x3_t test_vloxseg3ei16_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, co return __riscv_vloxseg3ei16_v_u64m2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x3_t test_vloxseg3ei16_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, c return __riscv_vloxseg3ei16_v_u64m2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg3ei32.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg3ei32.c index ecc9c9c56..061138827 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg3ei32.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg3ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf4x3_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf2x3_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m1x3_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vloxseg3ei32_v_u64m2x3_tu(vuint64m2x3_t vd, const uint64_t *r return __riscv_vloxseg3ei32_v_u64m2x3_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x3_t test_vloxseg3ei32_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, co return __riscv_vloxseg3ei32_v_u64m2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x3_t test_vloxseg3ei32_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, c return __riscv_vloxseg3ei32_v_u64m2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg3ei64.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg3ei64.c index eed3f3854..37001f0aa 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg3ei64.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg3ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf4x3_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf2x3_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m1x3_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -147,19 +147,19 @@ vuint64m2x3_t test_vloxseg3ei64_v_u64m2x3_tu(vuint64m2x3_t vd, const uint64_t *r return __riscv_vloxseg3ei64_v_u64m2x3_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -287,19 +287,19 @@ vuint64m2x3_t test_vloxseg3ei64_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, co return __riscv_vloxseg3ei64_v_u64m2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -427,19 +427,19 @@ vuint64m2x3_t test_vloxseg3ei64_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, c return __riscv_vloxseg3ei64_v_u64m2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg3ei8.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg3ei8.c index c002ee7cd..acea5a05c 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg3ei8.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg3ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf4x3_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf2x3_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m1x3_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vloxseg3ei8_v_u64m2x3_tu(vuint64m2x3_t vd, const uint64_t *rs return __riscv_vloxseg3ei8_v_u64m2x3_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x3_t test_vloxseg3ei8_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, con return __riscv_vloxseg3ei8_v_u64m2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x3_t test_vloxseg3ei8_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, co return __riscv_vloxseg3ei8_v_u64m2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg4ei16.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg4ei16.c index c9c5210d9..9cac2b1d6 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg4ei16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg4ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf4x4_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf2x4_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m1x4_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vloxseg4ei16_v_u64m2x4_tu(vuint64m2x4_t vd, const uint64_t *r return __riscv_vloxseg4ei16_v_u64m2x4_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x4_t test_vloxseg4ei16_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, co return __riscv_vloxseg4ei16_v_u64m2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x4_t test_vloxseg4ei16_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, c return __riscv_vloxseg4ei16_v_u64m2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg4ei32.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg4ei32.c index 60115bc8c..04f8d1838 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg4ei32.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg4ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf4x4_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf2x4_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m1x4_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vloxseg4ei32_v_u64m2x4_tu(vuint64m2x4_t vd, const uint64_t *r return __riscv_vloxseg4ei32_v_u64m2x4_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x4_t test_vloxseg4ei32_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, co return __riscv_vloxseg4ei32_v_u64m2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x4_t test_vloxseg4ei32_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, c return __riscv_vloxseg4ei32_v_u64m2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg4ei64.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg4ei64.c index 970677327..47acd75df 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg4ei64.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg4ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf4x4_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf2x4_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m1x4_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -147,19 +147,19 @@ vuint64m2x4_t test_vloxseg4ei64_v_u64m2x4_tu(vuint64m2x4_t vd, const uint64_t *r return __riscv_vloxseg4ei64_v_u64m2x4_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -287,19 +287,19 @@ vuint64m2x4_t test_vloxseg4ei64_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, co return __riscv_vloxseg4ei64_v_u64m2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -427,19 +427,19 @@ vuint64m2x4_t test_vloxseg4ei64_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, c return __riscv_vloxseg4ei64_v_u64m2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg4ei8.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg4ei8.c index d8fda3498..5ba3ae092 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg4ei8.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg4ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf4x4_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf2x4_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m1x4_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vloxseg4ei8_v_u64m2x4_tu(vuint64m2x4_t vd, const uint64_t *rs return __riscv_vloxseg4ei8_v_u64m2x4_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x4_t test_vloxseg4ei8_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, con return __riscv_vloxseg4ei8_v_u64m2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x4_t test_vloxseg4ei8_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, co return __riscv_vloxseg4ei8_v_u64m2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg5ei16.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg5ei16.c index 1f17ebfc8..a33a55ca1 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg5ei16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg5ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf4x5_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf2x5_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vloxseg5ei16_v_u64m1x5_tu(vuint64m1x5_t vd, const uint64_t *r return __riscv_vloxseg5ei16_v_u64m1x5_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x5_t test_vloxseg5ei16_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, co return __riscv_vloxseg5ei16_v_u64m1x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x5_t test_vloxseg5ei16_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, c return __riscv_vloxseg5ei16_v_u64m1x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg5ei32.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg5ei32.c index 0b36cc112..56b0d7e0a 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg5ei32.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg5ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf4x5_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf2x5_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vloxseg5ei32_v_u64m1x5_tu(vuint64m1x5_t vd, const uint64_t *r return __riscv_vloxseg5ei32_v_u64m1x5_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x5_t test_vloxseg5ei32_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, co return __riscv_vloxseg5ei32_v_u64m1x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x5_t test_vloxseg5ei32_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, c return __riscv_vloxseg5ei32_v_u64m1x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg5ei64.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg5ei64.c index a01927334..b0e9af8b8 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg5ei64.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg5ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf4x5_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf2x5_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vloxseg5ei64_v_u64m1x5_tu(vuint64m1x5_t vd, const uint64_t *r return __riscv_vloxseg5ei64_v_u64m1x5_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x5_t test_vloxseg5ei64_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, co return __riscv_vloxseg5ei64_v_u64m1x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x5_t test_vloxseg5ei64_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, c return __riscv_vloxseg5ei64_v_u64m1x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg5ei8.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg5ei8.c index 96fedb117..715e42ab0 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg5ei8.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg5ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf4x5_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf2x5_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vloxseg5ei8_v_u64m1x5_tu(vuint64m1x5_t vd, const uint64_t *rs return __riscv_vloxseg5ei8_v_u64m1x5_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x5_t test_vloxseg5ei8_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, con return __riscv_vloxseg5ei8_v_u64m1x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x5_t test_vloxseg5ei8_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, co return __riscv_vloxseg5ei8_v_u64m1x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg6ei16.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg6ei16.c index 08be2cbb8..9f840f2da 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg6ei16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg6ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf4x6_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf2x6_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vloxseg6ei16_v_u64m1x6_tu(vuint64m1x6_t vd, const uint64_t *r return __riscv_vloxseg6ei16_v_u64m1x6_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x6_t test_vloxseg6ei16_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, co return __riscv_vloxseg6ei16_v_u64m1x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x6_t test_vloxseg6ei16_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, c return __riscv_vloxseg6ei16_v_u64m1x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg6ei32.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg6ei32.c index 520f35f47..0d3044680 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg6ei32.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg6ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf4x6_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf2x6_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vloxseg6ei32_v_u64m1x6_tu(vuint64m1x6_t vd, const uint64_t *r return __riscv_vloxseg6ei32_v_u64m1x6_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x6_t test_vloxseg6ei32_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, co return __riscv_vloxseg6ei32_v_u64m1x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x6_t test_vloxseg6ei32_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, c return __riscv_vloxseg6ei32_v_u64m1x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg6ei64.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg6ei64.c index 98365289f..1f606b0ac 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg6ei64.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg6ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf4x6_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf2x6_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vloxseg6ei64_v_u64m1x6_tu(vuint64m1x6_t vd, const uint64_t *r return __riscv_vloxseg6ei64_v_u64m1x6_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x6_t test_vloxseg6ei64_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, co return __riscv_vloxseg6ei64_v_u64m1x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x6_t test_vloxseg6ei64_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, c return __riscv_vloxseg6ei64_v_u64m1x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg6ei8.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg6ei8.c index 6c7c1acf9..e3a28bd50 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg6ei8.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg6ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf4x6_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf2x6_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vloxseg6ei8_v_u64m1x6_tu(vuint64m1x6_t vd, const uint64_t *rs return __riscv_vloxseg6ei8_v_u64m1x6_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x6_t test_vloxseg6ei8_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, con return __riscv_vloxseg6ei8_v_u64m1x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x6_t test_vloxseg6ei8_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, co return __riscv_vloxseg6ei8_v_u64m1x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg7ei16.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg7ei16.c index 0e397b67f..79ed5105f 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg7ei16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg7ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf4x7_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf2x7_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vloxseg7ei16_v_u64m1x7_tu(vuint64m1x7_t vd, const uint64_t *r return __riscv_vloxseg7ei16_v_u64m1x7_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x7_t test_vloxseg7ei16_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, co return __riscv_vloxseg7ei16_v_u64m1x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x7_t test_vloxseg7ei16_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, c return __riscv_vloxseg7ei16_v_u64m1x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg7ei32.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg7ei32.c index 34dd703b4..807d36544 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg7ei32.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg7ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf4x7_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf2x7_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vloxseg7ei32_v_u64m1x7_tu(vuint64m1x7_t vd, const uint64_t *r return __riscv_vloxseg7ei32_v_u64m1x7_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x7_t test_vloxseg7ei32_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, co return __riscv_vloxseg7ei32_v_u64m1x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x7_t test_vloxseg7ei32_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, c return __riscv_vloxseg7ei32_v_u64m1x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg7ei64.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg7ei64.c index 71ea196cb..ee6d6a495 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg7ei64.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg7ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf4x7_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf2x7_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vloxseg7ei64_v_u64m1x7_tu(vuint64m1x7_t vd, const uint64_t *r return __riscv_vloxseg7ei64_v_u64m1x7_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x7_t test_vloxseg7ei64_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, co return __riscv_vloxseg7ei64_v_u64m1x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x7_t test_vloxseg7ei64_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, c return __riscv_vloxseg7ei64_v_u64m1x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg7ei8.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg7ei8.c index c339655f3..09e61dd27 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg7ei8.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg7ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf4x7_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf2x7_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vloxseg7ei8_v_u64m1x7_tu(vuint64m1x7_t vd, const uint64_t *rs return __riscv_vloxseg7ei8_v_u64m1x7_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x7_t test_vloxseg7ei8_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, con return __riscv_vloxseg7ei8_v_u64m1x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x7_t test_vloxseg7ei8_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, co return __riscv_vloxseg7ei8_v_u64m1x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg8ei16.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg8ei16.c index 135fe6f00..da5ac4e91 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg8ei16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg8ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf4x8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf2x8_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vloxseg8ei16_v_u64m1x8_tu(vuint64m1x8_t vd, const uint64_t *r return __riscv_vloxseg8ei16_v_u64m1x8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x8_t test_vloxseg8ei16_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, co return __riscv_vloxseg8ei16_v_u64m1x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x8_t test_vloxseg8ei16_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, c return __riscv_vloxseg8ei16_v_u64m1x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg8ei32.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg8ei32.c index 5c4da99c2..f29df8d5f 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg8ei32.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg8ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf4x8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf2x8_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vloxseg8ei32_v_u64m1x8_tu(vuint64m1x8_t vd, const uint64_t *r return __riscv_vloxseg8ei32_v_u64m1x8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x8_t test_vloxseg8ei32_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, co return __riscv_vloxseg8ei32_v_u64m1x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x8_t test_vloxseg8ei32_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, c return __riscv_vloxseg8ei32_v_u64m1x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg8ei64.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg8ei64.c index 716af4642..506ed2129 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg8ei64.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg8ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf4x8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf2x8_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vloxseg8ei64_v_u64m1x8_tu(vuint64m1x8_t vd, const uint64_t *r return __riscv_vloxseg8ei64_v_u64m1x8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x8_t test_vloxseg8ei64_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, co return __riscv_vloxseg8ei64_v_u64m1x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x8_t test_vloxseg8ei64_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, c return __riscv_vloxseg8ei64_v_u64m1x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vloxseg8ei8.c b/auto-generated/policy_funcs/gnu-api-tests/vloxseg8ei8.c index c8d8215e8..b9c3f2ab3 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vloxseg8ei8.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vloxseg8ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf4x8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf2x8_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vloxseg8ei8_v_u64m1x8_tu(vuint64m1x8_t vd, const uint64_t *rs return __riscv_vloxseg8ei8_v_u64m1x8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x8_t test_vloxseg8ei8_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, con return __riscv_vloxseg8ei8_v_u64m1x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x8_t test_vloxseg8ei8_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, co return __riscv_vloxseg8ei8_v_u64m1x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlse16.c b/auto-generated/policy_funcs/gnu-api-tests/vlse16.c index 4b8542209..c17b4ea5d 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlse16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlse16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vlse16_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4_t test_vlse16_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vlse16_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2_t test_vlse16_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vlse16_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1_t test_vlse16_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vlse16_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2_t test_vlse16_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m2_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vlse16_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4_t test_vlse16_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m4_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vlse16_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m8_t test_vlse16_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m8_tu(vd, rs1, rs2, vl); } @@ -79,27 +79,27 @@ vuint16m8_t test_vlse16_v_u16m8_tu(vuint16m8_t vd, const uint16_t *rs1, ptrdiff_ return __riscv_vlse16_v_u16m8_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vlse16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4_t test_vlse16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vlse16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2_t test_vlse16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vlse16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1_t test_vlse16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m1_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vlse16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2_t test_vlse16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vlse16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4_t test_vlse16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vlse16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m8_t test_vlse16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m8_tum(vm, vd, rs1, rs2, vl); } @@ -151,27 +151,27 @@ vuint16m8_t test_vlse16_v_u16m8_tum(vbool2_t vm, vuint16m8_t vd, const uint16_t return __riscv_vlse16_v_u16m8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vlse16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4_t test_vlse16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vlse16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2_t test_vlse16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vlse16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1_t test_vlse16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vlse16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2_t test_vlse16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vlse16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4_t test_vlse16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vlse16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m8_t test_vlse16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m8_tumu(vm, vd, rs1, rs2, vl); } @@ -223,27 +223,27 @@ vuint16m8_t test_vlse16_v_u16m8_tumu(vbool2_t vm, vuint16m8_t vd, const uint16_t return __riscv_vlse16_v_u16m8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vlse16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4_t test_vlse16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vlse16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2_t test_vlse16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vlse16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1_t test_vlse16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m1_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vlse16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2_t test_vlse16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vlse16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4_t test_vlse16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vlse16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m8_t test_vlse16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_v_f16m8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlseg2e16.c b/auto-generated/policy_funcs/gnu-api-tests/vlseg2e16.c index 14eeacbd1..46539d40c 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlseg2e16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlseg2e16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf4x2_tu(vd, rs1, vl); } -vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf2x2_tu(vd, rs1, vl); } -vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m1x2_tu(vd, rs1, vl); } -vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m2x2_tu(vd, rs1, vl); } -vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m4x2_tu(vd, rs1, vl); } @@ -67,23 +67,23 @@ vuint16m4x2_t test_vlseg2e16_v_u16m4x2_tu(vuint16m4x2_t vd, const uint16_t *rs1, return __riscv_vlseg2e16_v_u16m4x2_tu(vd, rs1, vl); } -vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf4x2_tum(vm, vd, rs1, vl); } -vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf2x2_tum(vm, vd, rs1, vl); } -vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m1x2_tum(vm, vd, rs1, vl); } -vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m2x2_tum(vm, vd, rs1, vl); } -vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m4x2_tum(vm, vd, rs1, vl); } @@ -127,23 +127,23 @@ vuint16m4x2_t test_vlseg2e16_v_u16m4x2_tum(vbool4_t vm, vuint16m4x2_t vd, const return __riscv_vlseg2e16_v_u16m4x2_tum(vm, vd, rs1, vl); } -vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf4x2_tumu(vm, vd, rs1, vl); } -vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf2x2_tumu(vm, vd, rs1, vl); } -vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m1x2_tumu(vm, vd, rs1, vl); } -vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m2x2_tumu(vm, vd, rs1, vl); } -vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m4x2_tumu(vm, vd, rs1, vl); } @@ -187,23 +187,23 @@ vuint16m4x2_t test_vlseg2e16_v_u16m4x2_tumu(vbool4_t vm, vuint16m4x2_t vd, const return __riscv_vlseg2e16_v_u16m4x2_tumu(vm, vd, rs1, vl); } -vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf4x2_mu(vm, vd, rs1, vl); } -vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16mf2x2_mu(vm, vd, rs1, vl); } -vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m1x2_mu(vm, vd, rs1, vl); } -vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m2x2_mu(vm, vd, rs1, vl); } -vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_v_f16m4x2_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlseg2e16ff.c b/auto-generated/policy_funcs/gnu-api-tests/vlseg2e16ff.c index 463160134..f25910c9a 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlseg2e16ff.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlseg2e16ff.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf4x2_tu(vd, rs1, new_vl, vl); } -vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf2x2_tu(vd, rs1, new_vl, vl); } -vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m1x2_tu(vd, rs1, new_vl, vl); } -vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m2x2_tu(vd, rs1, new_vl, vl); } -vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m4x2_tu(vd, rs1, new_vl, vl); } @@ -67,23 +67,23 @@ vuint16m4x2_t test_vlseg2e16ff_v_u16m4x2_tu(vuint16m4x2_t vd, const uint16_t *rs return __riscv_vlseg2e16ff_v_u16m4x2_tu(vd, rs1, new_vl, vl); } -vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf4x2_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf2x2_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m1x2_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m2x2_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m4x2_tum(vm, vd, rs1, new_vl, vl); } @@ -127,23 +127,23 @@ vuint16m4x2_t test_vlseg2e16ff_v_u16m4x2_tum(vbool4_t vm, vuint16m4x2_t vd, cons return __riscv_vlseg2e16ff_v_u16m4x2_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf4x2_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf2x2_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m1x2_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m2x2_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m4x2_tumu(vm, vd, rs1, new_vl, vl); } @@ -187,23 +187,23 @@ vuint16m4x2_t test_vlseg2e16ff_v_u16m4x2_tumu(vbool4_t vm, vuint16m4x2_t vd, con return __riscv_vlseg2e16ff_v_u16m4x2_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf4x2_mu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16mf2x2_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m1x2_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m2x2_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_v_f16m4x2_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlseg3e16.c b/auto-generated/policy_funcs/gnu-api-tests/vlseg3e16.c index a29912b40..ea1b40a19 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlseg3e16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlseg3e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf4x3_tu(vd, rs1, vl); } -vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf2x3_tu(vd, rs1, vl); } -vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m1x3_tu(vd, rs1, vl); } -vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m2x3_tu(vd, rs1, vl); } @@ -55,19 +55,19 @@ vuint16m2x3_t test_vlseg3e16_v_u16m2x3_tu(vuint16m2x3_t vd, const uint16_t *rs1, return __riscv_vlseg3e16_v_u16m2x3_tu(vd, rs1, vl); } -vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf4x3_tum(vm, vd, rs1, vl); } -vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf2x3_tum(vm, vd, rs1, vl); } -vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m1x3_tum(vm, vd, rs1, vl); } -vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m2x3_tum(vm, vd, rs1, vl); } @@ -103,19 +103,19 @@ vuint16m2x3_t test_vlseg3e16_v_u16m2x3_tum(vbool8_t vm, vuint16m2x3_t vd, const return __riscv_vlseg3e16_v_u16m2x3_tum(vm, vd, rs1, vl); } -vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf4x3_tumu(vm, vd, rs1, vl); } -vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf2x3_tumu(vm, vd, rs1, vl); } -vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m1x3_tumu(vm, vd, rs1, vl); } -vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m2x3_tumu(vm, vd, rs1, vl); } @@ -151,19 +151,19 @@ vuint16m2x3_t test_vlseg3e16_v_u16m2x3_tumu(vbool8_t vm, vuint16m2x3_t vd, const return __riscv_vlseg3e16_v_u16m2x3_tumu(vm, vd, rs1, vl); } -vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf4x3_mu(vm, vd, rs1, vl); } -vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16mf2x3_mu(vm, vd, rs1, vl); } -vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m1x3_mu(vm, vd, rs1, vl); } -vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_v_f16m2x3_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlseg3e16ff.c b/auto-generated/policy_funcs/gnu-api-tests/vlseg3e16ff.c index 9897c822f..6a35ba2b7 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlseg3e16ff.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlseg3e16ff.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf4x3_tu(vd, rs1, new_vl, vl); } -vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf2x3_tu(vd, rs1, new_vl, vl); } -vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m1x3_tu(vd, rs1, new_vl, vl); } -vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m2x3_tu(vd, rs1, new_vl, vl); } @@ -55,19 +55,19 @@ vuint16m2x3_t test_vlseg3e16ff_v_u16m2x3_tu(vuint16m2x3_t vd, const uint16_t *rs return __riscv_vlseg3e16ff_v_u16m2x3_tu(vd, rs1, new_vl, vl); } -vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf4x3_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf2x3_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m1x3_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m2x3_tum(vm, vd, rs1, new_vl, vl); } @@ -103,19 +103,19 @@ vuint16m2x3_t test_vlseg3e16ff_v_u16m2x3_tum(vbool8_t vm, vuint16m2x3_t vd, cons return __riscv_vlseg3e16ff_v_u16m2x3_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf4x3_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf2x3_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m1x3_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m2x3_tumu(vm, vd, rs1, new_vl, vl); } @@ -151,19 +151,19 @@ vuint16m2x3_t test_vlseg3e16ff_v_u16m2x3_tumu(vbool8_t vm, vuint16m2x3_t vd, con return __riscv_vlseg3e16ff_v_u16m2x3_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf4x3_mu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16mf2x3_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m1x3_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_v_f16m2x3_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlseg4e16.c b/auto-generated/policy_funcs/gnu-api-tests/vlseg4e16.c index b6220578c..08cba5db2 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlseg4e16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlseg4e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf4x4_tu(vd, rs1, vl); } -vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf2x4_tu(vd, rs1, vl); } -vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m1x4_tu(vd, rs1, vl); } -vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m2x4_tu(vd, rs1, vl); } @@ -55,19 +55,19 @@ vuint16m2x4_t test_vlseg4e16_v_u16m2x4_tu(vuint16m2x4_t vd, const uint16_t *rs1, return __riscv_vlseg4e16_v_u16m2x4_tu(vd, rs1, vl); } -vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf4x4_tum(vm, vd, rs1, vl); } -vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf2x4_tum(vm, vd, rs1, vl); } -vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m1x4_tum(vm, vd, rs1, vl); } -vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m2x4_tum(vm, vd, rs1, vl); } @@ -103,19 +103,19 @@ vuint16m2x4_t test_vlseg4e16_v_u16m2x4_tum(vbool8_t vm, vuint16m2x4_t vd, const return __riscv_vlseg4e16_v_u16m2x4_tum(vm, vd, rs1, vl); } -vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf4x4_tumu(vm, vd, rs1, vl); } -vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf2x4_tumu(vm, vd, rs1, vl); } -vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m1x4_tumu(vm, vd, rs1, vl); } -vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m2x4_tumu(vm, vd, rs1, vl); } @@ -151,19 +151,19 @@ vuint16m2x4_t test_vlseg4e16_v_u16m2x4_tumu(vbool8_t vm, vuint16m2x4_t vd, const return __riscv_vlseg4e16_v_u16m2x4_tumu(vm, vd, rs1, vl); } -vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf4x4_mu(vm, vd, rs1, vl); } -vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16mf2x4_mu(vm, vd, rs1, vl); } -vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m1x4_mu(vm, vd, rs1, vl); } -vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_v_f16m2x4_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlseg4e16ff.c b/auto-generated/policy_funcs/gnu-api-tests/vlseg4e16ff.c index facf345f6..9067a69db 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlseg4e16ff.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlseg4e16ff.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf4x4_tu(vd, rs1, new_vl, vl); } -vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf2x4_tu(vd, rs1, new_vl, vl); } -vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m1x4_tu(vd, rs1, new_vl, vl); } -vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m2x4_tu(vd, rs1, new_vl, vl); } @@ -55,19 +55,19 @@ vuint16m2x4_t test_vlseg4e16ff_v_u16m2x4_tu(vuint16m2x4_t vd, const uint16_t *rs return __riscv_vlseg4e16ff_v_u16m2x4_tu(vd, rs1, new_vl, vl); } -vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf4x4_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf2x4_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m1x4_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m2x4_tum(vm, vd, rs1, new_vl, vl); } @@ -103,19 +103,19 @@ vuint16m2x4_t test_vlseg4e16ff_v_u16m2x4_tum(vbool8_t vm, vuint16m2x4_t vd, cons return __riscv_vlseg4e16ff_v_u16m2x4_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf4x4_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf2x4_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m1x4_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m2x4_tumu(vm, vd, rs1, new_vl, vl); } @@ -151,19 +151,19 @@ vuint16m2x4_t test_vlseg4e16ff_v_u16m2x4_tumu(vbool8_t vm, vuint16m2x4_t vd, con return __riscv_vlseg4e16ff_v_u16m2x4_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf4x4_mu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16mf2x4_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m1x4_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_v_f16m2x4_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlseg5e16.c b/auto-generated/policy_funcs/gnu-api-tests/vlseg5e16.c index 1d5d41c7b..f8426c8a0 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlseg5e16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlseg5e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf4x5_tu(vd, rs1, vl); } -vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf2x5_tu(vd, rs1, vl); } -vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16m1x5_tu(vd, rs1, vl); } @@ -43,15 +43,15 @@ vuint16m1x5_t test_vlseg5e16_v_u16m1x5_tu(vuint16m1x5_t vd, const uint16_t *rs1, return __riscv_vlseg5e16_v_u16m1x5_tu(vd, rs1, vl); } -vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf4x5_tum(vm, vd, rs1, vl); } -vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf2x5_tum(vm, vd, rs1, vl); } -vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16m1x5_tum(vm, vd, rs1, vl); } @@ -79,15 +79,15 @@ vuint16m1x5_t test_vlseg5e16_v_u16m1x5_tum(vbool16_t vm, vuint16m1x5_t vd, const return __riscv_vlseg5e16_v_u16m1x5_tum(vm, vd, rs1, vl); } -vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf4x5_tumu(vm, vd, rs1, vl); } -vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf2x5_tumu(vm, vd, rs1, vl); } -vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16m1x5_tumu(vm, vd, rs1, vl); } @@ -115,15 +115,15 @@ vuint16m1x5_t test_vlseg5e16_v_u16m1x5_tumu(vbool16_t vm, vuint16m1x5_t vd, cons return __riscv_vlseg5e16_v_u16m1x5_tumu(vm, vd, rs1, vl); } -vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf4x5_mu(vm, vd, rs1, vl); } -vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16mf2x5_mu(vm, vd, rs1, vl); } -vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_v_f16m1x5_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlseg5e16ff.c b/auto-generated/policy_funcs/gnu-api-tests/vlseg5e16ff.c index a0fb8d0e3..99b487053 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlseg5e16ff.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlseg5e16ff.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf4x5_tu(vd, rs1, new_vl, vl); } -vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf2x5_tu(vd, rs1, new_vl, vl); } -vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16m1x5_tu(vd, rs1, new_vl, vl); } @@ -43,15 +43,15 @@ vuint16m1x5_t test_vlseg5e16ff_v_u16m1x5_tu(vuint16m1x5_t vd, const uint16_t *rs return __riscv_vlseg5e16ff_v_u16m1x5_tu(vd, rs1, new_vl, vl); } -vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf4x5_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf2x5_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16m1x5_tum(vm, vd, rs1, new_vl, vl); } @@ -79,15 +79,15 @@ vuint16m1x5_t test_vlseg5e16ff_v_u16m1x5_tum(vbool16_t vm, vuint16m1x5_t vd, con return __riscv_vlseg5e16ff_v_u16m1x5_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf4x5_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf2x5_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16m1x5_tumu(vm, vd, rs1, new_vl, vl); } @@ -115,15 +115,15 @@ vuint16m1x5_t test_vlseg5e16ff_v_u16m1x5_tumu(vbool16_t vm, vuint16m1x5_t vd, co return __riscv_vlseg5e16ff_v_u16m1x5_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf4x5_mu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16mf2x5_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_v_f16m1x5_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlseg6e16.c b/auto-generated/policy_funcs/gnu-api-tests/vlseg6e16.c index 11d8585bf..69ae34904 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlseg6e16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlseg6e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf4x6_tu(vd, rs1, vl); } -vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf2x6_tu(vd, rs1, vl); } -vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16m1x6_tu(vd, rs1, vl); } @@ -43,15 +43,15 @@ vuint16m1x6_t test_vlseg6e16_v_u16m1x6_tu(vuint16m1x6_t vd, const uint16_t *rs1, return __riscv_vlseg6e16_v_u16m1x6_tu(vd, rs1, vl); } -vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf4x6_tum(vm, vd, rs1, vl); } -vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf2x6_tum(vm, vd, rs1, vl); } -vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16m1x6_tum(vm, vd, rs1, vl); } @@ -79,15 +79,15 @@ vuint16m1x6_t test_vlseg6e16_v_u16m1x6_tum(vbool16_t vm, vuint16m1x6_t vd, const return __riscv_vlseg6e16_v_u16m1x6_tum(vm, vd, rs1, vl); } -vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf4x6_tumu(vm, vd, rs1, vl); } -vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf2x6_tumu(vm, vd, rs1, vl); } -vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16m1x6_tumu(vm, vd, rs1, vl); } @@ -115,15 +115,15 @@ vuint16m1x6_t test_vlseg6e16_v_u16m1x6_tumu(vbool16_t vm, vuint16m1x6_t vd, cons return __riscv_vlseg6e16_v_u16m1x6_tumu(vm, vd, rs1, vl); } -vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf4x6_mu(vm, vd, rs1, vl); } -vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16mf2x6_mu(vm, vd, rs1, vl); } -vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_v_f16m1x6_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlseg6e16ff.c b/auto-generated/policy_funcs/gnu-api-tests/vlseg6e16ff.c index b08855c9b..67d9253a9 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlseg6e16ff.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlseg6e16ff.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf4x6_tu(vd, rs1, new_vl, vl); } -vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf2x6_tu(vd, rs1, new_vl, vl); } -vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16m1x6_tu(vd, rs1, new_vl, vl); } @@ -43,15 +43,15 @@ vuint16m1x6_t test_vlseg6e16ff_v_u16m1x6_tu(vuint16m1x6_t vd, const uint16_t *rs return __riscv_vlseg6e16ff_v_u16m1x6_tu(vd, rs1, new_vl, vl); } -vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf4x6_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf2x6_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16m1x6_tum(vm, vd, rs1, new_vl, vl); } @@ -79,15 +79,15 @@ vuint16m1x6_t test_vlseg6e16ff_v_u16m1x6_tum(vbool16_t vm, vuint16m1x6_t vd, con return __riscv_vlseg6e16ff_v_u16m1x6_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf4x6_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf2x6_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16m1x6_tumu(vm, vd, rs1, new_vl, vl); } @@ -115,15 +115,15 @@ vuint16m1x6_t test_vlseg6e16ff_v_u16m1x6_tumu(vbool16_t vm, vuint16m1x6_t vd, co return __riscv_vlseg6e16ff_v_u16m1x6_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf4x6_mu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16mf2x6_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_v_f16m1x6_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlseg7e16.c b/auto-generated/policy_funcs/gnu-api-tests/vlseg7e16.c index 809f64548..8d73c5ed1 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlseg7e16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlseg7e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf4x7_tu(vd, rs1, vl); } -vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf2x7_tu(vd, rs1, vl); } -vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16m1x7_tu(vd, rs1, vl); } @@ -43,15 +43,15 @@ vuint16m1x7_t test_vlseg7e16_v_u16m1x7_tu(vuint16m1x7_t vd, const uint16_t *rs1, return __riscv_vlseg7e16_v_u16m1x7_tu(vd, rs1, vl); } -vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf4x7_tum(vm, vd, rs1, vl); } -vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf2x7_tum(vm, vd, rs1, vl); } -vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16m1x7_tum(vm, vd, rs1, vl); } @@ -79,15 +79,15 @@ vuint16m1x7_t test_vlseg7e16_v_u16m1x7_tum(vbool16_t vm, vuint16m1x7_t vd, const return __riscv_vlseg7e16_v_u16m1x7_tum(vm, vd, rs1, vl); } -vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf4x7_tumu(vm, vd, rs1, vl); } -vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf2x7_tumu(vm, vd, rs1, vl); } -vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16m1x7_tumu(vm, vd, rs1, vl); } @@ -115,15 +115,15 @@ vuint16m1x7_t test_vlseg7e16_v_u16m1x7_tumu(vbool16_t vm, vuint16m1x7_t vd, cons return __riscv_vlseg7e16_v_u16m1x7_tumu(vm, vd, rs1, vl); } -vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf4x7_mu(vm, vd, rs1, vl); } -vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16mf2x7_mu(vm, vd, rs1, vl); } -vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_v_f16m1x7_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlseg7e16ff.c b/auto-generated/policy_funcs/gnu-api-tests/vlseg7e16ff.c index 15a31378f..5a922bf5f 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlseg7e16ff.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlseg7e16ff.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf4x7_tu(vd, rs1, new_vl, vl); } -vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf2x7_tu(vd, rs1, new_vl, vl); } -vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16m1x7_tu(vd, rs1, new_vl, vl); } @@ -43,15 +43,15 @@ vuint16m1x7_t test_vlseg7e16ff_v_u16m1x7_tu(vuint16m1x7_t vd, const uint16_t *rs return __riscv_vlseg7e16ff_v_u16m1x7_tu(vd, rs1, new_vl, vl); } -vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf4x7_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf2x7_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16m1x7_tum(vm, vd, rs1, new_vl, vl); } @@ -79,15 +79,15 @@ vuint16m1x7_t test_vlseg7e16ff_v_u16m1x7_tum(vbool16_t vm, vuint16m1x7_t vd, con return __riscv_vlseg7e16ff_v_u16m1x7_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf4x7_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf2x7_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16m1x7_tumu(vm, vd, rs1, new_vl, vl); } @@ -115,15 +115,15 @@ vuint16m1x7_t test_vlseg7e16ff_v_u16m1x7_tumu(vbool16_t vm, vuint16m1x7_t vd, co return __riscv_vlseg7e16ff_v_u16m1x7_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf4x7_mu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16mf2x7_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_v_f16m1x7_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlseg8e16.c b/auto-generated/policy_funcs/gnu-api-tests/vlseg8e16.c index 4442e6f8d..6493a9047 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlseg8e16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlseg8e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf4x8_tu(vd, rs1, vl); } -vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf2x8_tu(vd, rs1, vl); } -vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16m1x8_tu(vd, rs1, vl); } @@ -43,15 +43,15 @@ vuint16m1x8_t test_vlseg8e16_v_u16m1x8_tu(vuint16m1x8_t vd, const uint16_t *rs1, return __riscv_vlseg8e16_v_u16m1x8_tu(vd, rs1, vl); } -vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf4x8_tum(vm, vd, rs1, vl); } -vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf2x8_tum(vm, vd, rs1, vl); } -vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16m1x8_tum(vm, vd, rs1, vl); } @@ -79,15 +79,15 @@ vuint16m1x8_t test_vlseg8e16_v_u16m1x8_tum(vbool16_t vm, vuint16m1x8_t vd, const return __riscv_vlseg8e16_v_u16m1x8_tum(vm, vd, rs1, vl); } -vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf4x8_tumu(vm, vd, rs1, vl); } -vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf2x8_tumu(vm, vd, rs1, vl); } -vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16m1x8_tumu(vm, vd, rs1, vl); } @@ -115,15 +115,15 @@ vuint16m1x8_t test_vlseg8e16_v_u16m1x8_tumu(vbool16_t vm, vuint16m1x8_t vd, cons return __riscv_vlseg8e16_v_u16m1x8_tumu(vm, vd, rs1, vl); } -vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf4x8_mu(vm, vd, rs1, vl); } -vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16mf2x8_mu(vm, vd, rs1, vl); } -vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_v_f16m1x8_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlseg8e16ff.c b/auto-generated/policy_funcs/gnu-api-tests/vlseg8e16ff.c index ec7c6d0ef..f94d6ee35 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlseg8e16ff.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlseg8e16ff.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf4x8_tu(vd, rs1, new_vl, vl); } -vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf2x8_tu(vd, rs1, new_vl, vl); } -vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16m1x8_tu(vd, rs1, new_vl, vl); } @@ -43,15 +43,15 @@ vuint16m1x8_t test_vlseg8e16ff_v_u16m1x8_tu(vuint16m1x8_t vd, const uint16_t *rs return __riscv_vlseg8e16ff_v_u16m1x8_tu(vd, rs1, new_vl, vl); } -vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf4x8_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf2x8_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16m1x8_tum(vm, vd, rs1, new_vl, vl); } @@ -79,15 +79,15 @@ vuint16m1x8_t test_vlseg8e16ff_v_u16m1x8_tum(vbool16_t vm, vuint16m1x8_t vd, con return __riscv_vlseg8e16ff_v_u16m1x8_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf4x8_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf2x8_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16m1x8_tumu(vm, vd, rs1, new_vl, vl); } @@ -115,15 +115,15 @@ vuint16m1x8_t test_vlseg8e16ff_v_u16m1x8_tumu(vbool16_t vm, vuint16m1x8_t vd, co return __riscv_vlseg8e16ff_v_u16m1x8_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf4x8_mu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16mf2x8_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_v_f16m1x8_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlsseg2e16.c b/auto-generated/policy_funcs/gnu-api-tests/vlsseg2e16.c index 4544177b6..8d2015cd5 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlsseg2e16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlsseg2e16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf2x2_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m1x2_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m2x2_tu(vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m4x2_tu(vd, rs1, rs2, vl); } @@ -67,23 +67,23 @@ vuint16m4x2_t test_vlsseg2e16_v_u16m4x2_tu(vuint16m4x2_t vd, const uint16_t *rs1 return __riscv_vlsseg2e16_v_u16m4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m4x2_tum(vm, vd, rs1, rs2, vl); } @@ -127,23 +127,23 @@ vuint16m4x2_t test_vlsseg2e16_v_u16m4x2_tum(vbool4_t vm, vuint16m4x2_t vd, const return __riscv_vlsseg2e16_v_u16m4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m4x2_tumu(vm, vd, rs1, rs2, vl); } @@ -187,23 +187,23 @@ vuint16m4x2_t test_vlsseg2e16_v_u16m4x2_tumu(vbool4_t vm, vuint16m4x2_t vd, cons return __riscv_vlsseg2e16_v_u16m4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_v_f16m4x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlsseg3e16.c b/auto-generated/policy_funcs/gnu-api-tests/vlsseg3e16.c index 50829c0e8..feb35e977 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlsseg3e16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlsseg3e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf4x3_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf2x3_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m1x3_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -55,19 +55,19 @@ vuint16m2x3_t test_vlsseg3e16_v_u16m2x3_tu(vuint16m2x3_t vd, const uint16_t *rs1 return __riscv_vlsseg3e16_v_u16m2x3_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -103,19 +103,19 @@ vuint16m2x3_t test_vlsseg3e16_v_u16m2x3_tum(vbool8_t vm, vuint16m2x3_t vd, const return __riscv_vlsseg3e16_v_u16m2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -151,19 +151,19 @@ vuint16m2x3_t test_vlsseg3e16_v_u16m2x3_tumu(vbool8_t vm, vuint16m2x3_t vd, cons return __riscv_vlsseg3e16_v_u16m2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlsseg4e16.c b/auto-generated/policy_funcs/gnu-api-tests/vlsseg4e16.c index efdb440ef..c3bd06e6b 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlsseg4e16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlsseg4e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf4x4_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf2x4_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m1x4_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -55,19 +55,19 @@ vuint16m2x4_t test_vlsseg4e16_v_u16m2x4_tu(vuint16m2x4_t vd, const uint16_t *rs1 return __riscv_vlsseg4e16_v_u16m2x4_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -103,19 +103,19 @@ vuint16m2x4_t test_vlsseg4e16_v_u16m2x4_tum(vbool8_t vm, vuint16m2x4_t vd, const return __riscv_vlsseg4e16_v_u16m2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -151,19 +151,19 @@ vuint16m2x4_t test_vlsseg4e16_v_u16m2x4_tumu(vbool8_t vm, vuint16m2x4_t vd, cons return __riscv_vlsseg4e16_v_u16m2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlsseg5e16.c b/auto-generated/policy_funcs/gnu-api-tests/vlsseg5e16.c index ac202b315..c95f82045 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlsseg5e16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlsseg5e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf4x5_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf2x5_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -43,15 +43,15 @@ vuint16m1x5_t test_vlsseg5e16_v_u16m1x5_tu(vuint16m1x5_t vd, const uint16_t *rs1 return __riscv_vlsseg5e16_v_u16m1x5_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -79,15 +79,15 @@ vuint16m1x5_t test_vlsseg5e16_v_u16m1x5_tum(vbool16_t vm, vuint16m1x5_t vd, cons return __riscv_vlsseg5e16_v_u16m1x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -115,15 +115,15 @@ vuint16m1x5_t test_vlsseg5e16_v_u16m1x5_tumu(vbool16_t vm, vuint16m1x5_t vd, con return __riscv_vlsseg5e16_v_u16m1x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlsseg6e16.c b/auto-generated/policy_funcs/gnu-api-tests/vlsseg6e16.c index d84e71820..9da4c375c 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlsseg6e16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlsseg6e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf4x6_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf2x6_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -43,15 +43,15 @@ vuint16m1x6_t test_vlsseg6e16_v_u16m1x6_tu(vuint16m1x6_t vd, const uint16_t *rs1 return __riscv_vlsseg6e16_v_u16m1x6_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -79,15 +79,15 @@ vuint16m1x6_t test_vlsseg6e16_v_u16m1x6_tum(vbool16_t vm, vuint16m1x6_t vd, cons return __riscv_vlsseg6e16_v_u16m1x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -115,15 +115,15 @@ vuint16m1x6_t test_vlsseg6e16_v_u16m1x6_tumu(vbool16_t vm, vuint16m1x6_t vd, con return __riscv_vlsseg6e16_v_u16m1x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlsseg7e16.c b/auto-generated/policy_funcs/gnu-api-tests/vlsseg7e16.c index 60d28f7d9..4cb1595d7 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlsseg7e16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlsseg7e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf4x7_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf2x7_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -43,15 +43,15 @@ vuint16m1x7_t test_vlsseg7e16_v_u16m1x7_tu(vuint16m1x7_t vd, const uint16_t *rs1 return __riscv_vlsseg7e16_v_u16m1x7_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -79,15 +79,15 @@ vuint16m1x7_t test_vlsseg7e16_v_u16m1x7_tum(vbool16_t vm, vuint16m1x7_t vd, cons return __riscv_vlsseg7e16_v_u16m1x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -115,15 +115,15 @@ vuint16m1x7_t test_vlsseg7e16_v_u16m1x7_tumu(vbool16_t vm, vuint16m1x7_t vd, con return __riscv_vlsseg7e16_v_u16m1x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vlsseg8e16.c b/auto-generated/policy_funcs/gnu-api-tests/vlsseg8e16.c index 7aeb762f9..1acd4dae4 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vlsseg8e16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vlsseg8e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf4x8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf2x8_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -43,15 +43,15 @@ vuint16m1x8_t test_vlsseg8e16_v_u16m1x8_tu(vuint16m1x8_t vd, const uint16_t *rs1 return __riscv_vlsseg8e16_v_u16m1x8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -79,15 +79,15 @@ vuint16m1x8_t test_vlsseg8e16_v_u16m1x8_tum(vbool16_t vm, vuint16m1x8_t vd, cons return __riscv_vlsseg8e16_v_u16m1x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -115,15 +115,15 @@ vuint16m1x8_t test_vlsseg8e16_v_u16m1x8_tumu(vbool16_t vm, vuint16m1x8_t vd, con return __riscv_vlsseg8e16_v_u16m1x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxei16.c b/auto-generated/policy_funcs/gnu-api-tests/vluxei16.c index 72034d45f..bac73d6bd 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxei16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxei16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei16_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei16_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei16_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vluxei16_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vluxei16_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m2_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vluxei16_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m4_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vluxei16_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m8_tu(vd, rs1, rs2, vl); } @@ -235,27 +235,27 @@ vuint64m8_t test_vluxei16_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, vuint1 return __riscv_vluxei16_v_u64m8_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vluxei16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m1_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vluxei16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vluxei16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vluxei16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m8_tum(vm, vd, rs1, rs2, vl); } @@ -463,27 +463,27 @@ vuint64m8_t test_vluxei16_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, const uint64_ return __riscv_vluxei16_v_u64m8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vluxei16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vluxei16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vluxei16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vluxei16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m8_tumu(vm, vd, rs1, rs2, vl); } @@ -691,27 +691,27 @@ vuint64m8_t test_vluxei16_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, const uint64 return __riscv_vluxei16_v_u64m8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vluxei16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m1_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vluxei16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vluxei16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vluxei16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_v_f16m8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxei32.c b/auto-generated/policy_funcs/gnu-api-tests/vluxei32.c index ef38b0157..bf28193a7 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxei32.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei32_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei32_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei32_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei32_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vluxei32_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m2_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vluxei32_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m4_tu(vd, rs1, rs2, vl); } @@ -215,23 +215,23 @@ vuint64m8_t test_vluxei32_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, vuint3 return __riscv_vluxei32_v_u64m8_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei32_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei32_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei32_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei32_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m1_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vluxei32_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vluxei32_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m4_tum(vm, vd, rs1, rs2, vl); } @@ -423,23 +423,23 @@ vuint64m8_t test_vluxei32_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, const uint64_ return __riscv_vluxei32_v_u64m8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei32_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei32_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei32_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei32_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vluxei32_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vluxei32_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m4_tumu(vm, vd, rs1, rs2, vl); } @@ -631,23 +631,23 @@ vuint64m8_t test_vluxei32_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, const uint64 return __riscv_vluxei32_v_u64m8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei32_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei32_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei32_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei32_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m1_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vluxei32_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vluxei32_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_v_f16m4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxei64.c b/auto-generated/policy_funcs/gnu-api-tests/vluxei64.c index f32da7680..8d993cd28 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxei64.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei64_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei64_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei64_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vluxei64_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vluxei64_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m2_tu(vd, rs1, rs2, vl); } @@ -183,19 +183,19 @@ vuint64m8_t test_vluxei64_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, vuint6 return __riscv_vluxei64_v_u64m8_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei64_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei64_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei64_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vluxei64_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m1_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vluxei64_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m2_tum(vm, vd, rs1, rs2, vl); } @@ -359,19 +359,19 @@ vuint64m8_t test_vluxei64_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, const uint64_ return __riscv_vluxei64_v_u64m8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei64_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei64_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei64_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vluxei64_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vluxei64_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } @@ -535,19 +535,19 @@ vuint64m8_t test_vluxei64_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, const uint64 return __riscv_vluxei64_v_u64m8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei64_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei64_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei64_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vluxei64_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m1_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vluxei64_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_v_f16m2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxei8.c b/auto-generated/policy_funcs/gnu-api-tests/vluxei8.c index 402e0ecf2..442decbcd 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxei8.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxei8.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei8_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei8_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf4_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei8_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf2_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei8_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m1_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vluxei8_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m2_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vluxei8_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m4_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vluxei8_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m8_tu(vd, rs1, rs2, vl); } @@ -243,27 +243,27 @@ vuint64m8_t test_vluxei8_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, vuint8m return __riscv_vluxei8_v_u64m8_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei8_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei8_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei8_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei8_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m1_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vluxei8_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vluxei8_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vluxei8_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m8_tum(vm, vd, rs1, rs2, vl); } @@ -479,27 +479,27 @@ vuint64m8_t test_vluxei8_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, const uint64_t return __riscv_vluxei8_v_u64m8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei8_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei8_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei8_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei8_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m1_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vluxei8_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vluxei8_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vluxei8_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m8_tumu(vm, vd, rs1, rs2, vl); } @@ -715,27 +715,27 @@ vuint64m8_t test_vluxei8_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, const uint64_ return __riscv_vluxei8_v_u64m8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei8_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei8_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei8_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16mf2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei8_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m1_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vluxei8_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vluxei8_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vluxei8_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_v_f16m8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg2ei16.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg2ei16.c index 558674611..cb7a7cc6a 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg2ei16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg2ei16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf2x2_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m1x2_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m2x2_tu(vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m4x2_tu(vd, rs1, rs2, vl); } @@ -199,23 +199,23 @@ vuint64m4x2_t test_vluxseg2ei16_v_u64m4x2_tu(vuint64m4x2_t vd, const uint64_t *r return __riscv_vluxseg2ei16_v_u64m4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m4x2_tum(vm, vd, rs1, rs2, vl); } @@ -391,23 +391,23 @@ vuint64m4x2_t test_vluxseg2ei16_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, co return __riscv_vluxseg2ei16_v_u64m4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m4x2_tumu(vm, vd, rs1, rs2, vl); } @@ -583,23 +583,23 @@ vuint64m4x2_t test_vluxseg2ei16_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, c return __riscv_vluxseg2ei16_v_u64m4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_v_f16m4x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg2ei32.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg2ei32.c index 31aead879..e0bf2af21 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg2ei32.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg2ei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf2x2_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m1x2_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m2x2_tu(vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m4x2_tu(vd, rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m4x2_t test_vluxseg2ei32_v_u64m4x2_tu(vuint64m4x2_t vd, const uint64_t *r return __riscv_vluxseg2ei32_v_u64m4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m4x2_tum(vm, vd, rs1, rs2, vl); } @@ -375,23 +375,23 @@ vuint64m4x2_t test_vluxseg2ei32_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, co return __riscv_vluxseg2ei32_v_u64m4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m4x2_tumu(vm, vd, rs1, rs2, vl); } @@ -559,23 +559,23 @@ vuint64m4x2_t test_vluxseg2ei32_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, c return __riscv_vluxseg2ei32_v_u64m4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_v_f16m4x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg2ei64.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg2ei64.c index cc2c72472..3dcfae461 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg2ei64.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg2ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf2x2_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m1x2_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m2x2_tu(vd, rs1, rs2, vl); } @@ -171,19 +171,19 @@ vuint64m4x2_t test_vluxseg2ei64_v_u64m4x2_tu(vuint64m4x2_t vd, const uint64_t *r return __riscv_vluxseg2ei64_v_u64m4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } @@ -335,19 +335,19 @@ vuint64m4x2_t test_vluxseg2ei64_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, co return __riscv_vluxseg2ei64_v_u64m4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } @@ -499,19 +499,19 @@ vuint64m4x2_t test_vluxseg2ei64_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, c return __riscv_vluxseg2ei64_v_u64m4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg2ei8.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg2ei8.c index 90c598dac..dcc052126 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg2ei8.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg2ei8.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf2x2_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m1x2_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m2x2_tu(vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m4x2_tu(vd, rs1, rs2, vl); } @@ -199,23 +199,23 @@ vuint64m4x2_t test_vluxseg2ei8_v_u64m4x2_tu(vuint64m4x2_t vd, const uint64_t *rs return __riscv_vluxseg2ei8_v_u64m4x2_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf2x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m1x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m2x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m4x2_tum(vm, vd, rs1, rs2, vl); } @@ -391,23 +391,23 @@ vuint64m4x2_t test_vluxseg2ei8_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, con return __riscv_vluxseg2ei8_v_u64m4x2_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf2x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m1x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m2x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m4x2_tumu(vm, vd, rs1, rs2, vl); } @@ -583,23 +583,23 @@ vuint64m4x2_t test_vluxseg2ei8_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, co return __riscv_vluxseg2ei8_v_u64m4x2_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf4x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16mf2x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m1x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m2x2_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_v_f16m4x2_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg3ei16.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg3ei16.c index 7eb9cfdef..3b5a57b73 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg3ei16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg3ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf4x3_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf2x3_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m1x3_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vluxseg3ei16_v_u64m2x3_tu(vuint64m2x3_t vd, const uint64_t *r return __riscv_vluxseg3ei16_v_u64m2x3_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x3_t test_vluxseg3ei16_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, co return __riscv_vluxseg3ei16_v_u64m2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x3_t test_vluxseg3ei16_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, c return __riscv_vluxseg3ei16_v_u64m2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg3ei32.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg3ei32.c index 52bddd26f..1c93a314d 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg3ei32.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg3ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf4x3_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf2x3_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m1x3_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vluxseg3ei32_v_u64m2x3_tu(vuint64m2x3_t vd, const uint64_t *r return __riscv_vluxseg3ei32_v_u64m2x3_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x3_t test_vluxseg3ei32_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, co return __riscv_vluxseg3ei32_v_u64m2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x3_t test_vluxseg3ei32_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, c return __riscv_vluxseg3ei32_v_u64m2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg3ei64.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg3ei64.c index bce92c39b..f97d12f63 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg3ei64.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg3ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf4x3_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf2x3_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m1x3_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -147,19 +147,19 @@ vuint64m2x3_t test_vluxseg3ei64_v_u64m2x3_tu(vuint64m2x3_t vd, const uint64_t *r return __riscv_vluxseg3ei64_v_u64m2x3_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -287,19 +287,19 @@ vuint64m2x3_t test_vluxseg3ei64_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, co return __riscv_vluxseg3ei64_v_u64m2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -427,19 +427,19 @@ vuint64m2x3_t test_vluxseg3ei64_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, c return __riscv_vluxseg3ei64_v_u64m2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg3ei8.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg3ei8.c index a22d9cc36..28f829af5 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg3ei8.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg3ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf4x3_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf2x3_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m1x3_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m2x3_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vluxseg3ei8_v_u64m2x3_tu(vuint64m2x3_t vd, const uint64_t *rs return __riscv_vluxseg3ei8_v_u64m2x3_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf4x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m1x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m2x3_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x3_t test_vluxseg3ei8_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, con return __riscv_vluxseg3ei8_v_u64m2x3_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf4x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m1x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m2x3_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x3_t test_vluxseg3ei8_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, co return __riscv_vluxseg3ei8_v_u64m2x3_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf4x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16mf2x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m1x3_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_v_f16m2x3_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg4ei16.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg4ei16.c index a8d7c6045..92046d8a2 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg4ei16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg4ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf4x4_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf2x4_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m1x4_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vluxseg4ei16_v_u64m2x4_tu(vuint64m2x4_t vd, const uint64_t *r return __riscv_vluxseg4ei16_v_u64m2x4_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x4_t test_vluxseg4ei16_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, co return __riscv_vluxseg4ei16_v_u64m2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x4_t test_vluxseg4ei16_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, c return __riscv_vluxseg4ei16_v_u64m2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg4ei32.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg4ei32.c index 0f54d2eb6..a4ae096f2 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg4ei32.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg4ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf4x4_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf2x4_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m1x4_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vluxseg4ei32_v_u64m2x4_tu(vuint64m2x4_t vd, const uint64_t *r return __riscv_vluxseg4ei32_v_u64m2x4_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x4_t test_vluxseg4ei32_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, co return __riscv_vluxseg4ei32_v_u64m2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x4_t test_vluxseg4ei32_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, c return __riscv_vluxseg4ei32_v_u64m2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg4ei64.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg4ei64.c index 0ce79fddd..5258b943c 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg4ei64.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg4ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf4x4_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf2x4_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m1x4_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -147,19 +147,19 @@ vuint64m2x4_t test_vluxseg4ei64_v_u64m2x4_tu(vuint64m2x4_t vd, const uint64_t *r return __riscv_vluxseg4ei64_v_u64m2x4_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -287,19 +287,19 @@ vuint64m2x4_t test_vluxseg4ei64_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, co return __riscv_vluxseg4ei64_v_u64m2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -427,19 +427,19 @@ vuint64m2x4_t test_vluxseg4ei64_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, c return __riscv_vluxseg4ei64_v_u64m2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg4ei8.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg4ei8.c index 9fa7622e4..66b5d0411 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg4ei8.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg4ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf4x4_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf2x4_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m1x4_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m2x4_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vluxseg4ei8_v_u64m2x4_tu(vuint64m2x4_t vd, const uint64_t *rs return __riscv_vluxseg4ei8_v_u64m2x4_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf4x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m1x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m2x4_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x4_t test_vluxseg4ei8_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, con return __riscv_vluxseg4ei8_v_u64m2x4_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf4x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m1x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m2x4_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x4_t test_vluxseg4ei8_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, co return __riscv_vluxseg4ei8_v_u64m2x4_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf4x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16mf2x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m1x4_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_v_f16m2x4_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg5ei16.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg5ei16.c index 1b60c1fce..e1e826791 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg5ei16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg5ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf4x5_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf2x5_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vluxseg5ei16_v_u64m1x5_tu(vuint64m1x5_t vd, const uint64_t *r return __riscv_vluxseg5ei16_v_u64m1x5_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x5_t test_vluxseg5ei16_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, co return __riscv_vluxseg5ei16_v_u64m1x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x5_t test_vluxseg5ei16_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, c return __riscv_vluxseg5ei16_v_u64m1x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg5ei32.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg5ei32.c index 5bcd0fe98..311794ad4 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg5ei32.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg5ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf4x5_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf2x5_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vluxseg5ei32_v_u64m1x5_tu(vuint64m1x5_t vd, const uint64_t *r return __riscv_vluxseg5ei32_v_u64m1x5_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x5_t test_vluxseg5ei32_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, co return __riscv_vluxseg5ei32_v_u64m1x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x5_t test_vluxseg5ei32_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, c return __riscv_vluxseg5ei32_v_u64m1x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg5ei64.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg5ei64.c index cfedb0fdf..af5d4aa7e 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg5ei64.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg5ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf4x5_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf2x5_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vluxseg5ei64_v_u64m1x5_tu(vuint64m1x5_t vd, const uint64_t *r return __riscv_vluxseg5ei64_v_u64m1x5_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x5_t test_vluxseg5ei64_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, co return __riscv_vluxseg5ei64_v_u64m1x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x5_t test_vluxseg5ei64_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, c return __riscv_vluxseg5ei64_v_u64m1x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg5ei8.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg5ei8.c index cfb5c17e3..786ae38f8 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg5ei8.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg5ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf4x5_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf2x5_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16m1x5_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vluxseg5ei8_v_u64m1x5_tu(vuint64m1x5_t vd, const uint64_t *rs return __riscv_vluxseg5ei8_v_u64m1x5_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf4x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf2x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16m1x5_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x5_t test_vluxseg5ei8_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, con return __riscv_vluxseg5ei8_v_u64m1x5_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf4x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf2x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16m1x5_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x5_t test_vluxseg5ei8_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, co return __riscv_vluxseg5ei8_v_u64m1x5_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf4x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16mf2x5_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_v_f16m1x5_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg6ei16.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg6ei16.c index 517f89c25..7f6938daa 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg6ei16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg6ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf4x6_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf2x6_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vluxseg6ei16_v_u64m1x6_tu(vuint64m1x6_t vd, const uint64_t *r return __riscv_vluxseg6ei16_v_u64m1x6_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x6_t test_vluxseg6ei16_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, co return __riscv_vluxseg6ei16_v_u64m1x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x6_t test_vluxseg6ei16_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, c return __riscv_vluxseg6ei16_v_u64m1x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg6ei32.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg6ei32.c index f8b5ded9f..70c41d28c 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg6ei32.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg6ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf4x6_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf2x6_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vluxseg6ei32_v_u64m1x6_tu(vuint64m1x6_t vd, const uint64_t *r return __riscv_vluxseg6ei32_v_u64m1x6_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x6_t test_vluxseg6ei32_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, co return __riscv_vluxseg6ei32_v_u64m1x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x6_t test_vluxseg6ei32_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, c return __riscv_vluxseg6ei32_v_u64m1x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg6ei64.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg6ei64.c index 9cedaa10f..bb4cceea7 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg6ei64.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg6ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf4x6_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf2x6_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vluxseg6ei64_v_u64m1x6_tu(vuint64m1x6_t vd, const uint64_t *r return __riscv_vluxseg6ei64_v_u64m1x6_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x6_t test_vluxseg6ei64_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, co return __riscv_vluxseg6ei64_v_u64m1x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x6_t test_vluxseg6ei64_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, c return __riscv_vluxseg6ei64_v_u64m1x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg6ei8.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg6ei8.c index 6b931897a..ed29ca66b 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg6ei8.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg6ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf4x6_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf2x6_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16m1x6_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vluxseg6ei8_v_u64m1x6_tu(vuint64m1x6_t vd, const uint64_t *rs return __riscv_vluxseg6ei8_v_u64m1x6_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf4x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf2x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16m1x6_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x6_t test_vluxseg6ei8_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, con return __riscv_vluxseg6ei8_v_u64m1x6_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf4x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf2x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16m1x6_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x6_t test_vluxseg6ei8_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, co return __riscv_vluxseg6ei8_v_u64m1x6_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf4x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16mf2x6_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_v_f16m1x6_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg7ei16.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg7ei16.c index 7c490a0a5..870dbdd7b 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg7ei16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg7ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf4x7_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf2x7_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vluxseg7ei16_v_u64m1x7_tu(vuint64m1x7_t vd, const uint64_t *r return __riscv_vluxseg7ei16_v_u64m1x7_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x7_t test_vluxseg7ei16_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, co return __riscv_vluxseg7ei16_v_u64m1x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x7_t test_vluxseg7ei16_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, c return __riscv_vluxseg7ei16_v_u64m1x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg7ei32.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg7ei32.c index cd533542b..5d6c239b1 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg7ei32.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg7ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf4x7_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf2x7_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vluxseg7ei32_v_u64m1x7_tu(vuint64m1x7_t vd, const uint64_t *r return __riscv_vluxseg7ei32_v_u64m1x7_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x7_t test_vluxseg7ei32_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, co return __riscv_vluxseg7ei32_v_u64m1x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x7_t test_vluxseg7ei32_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, c return __riscv_vluxseg7ei32_v_u64m1x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg7ei64.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg7ei64.c index 2bd000427..b2df8b4fb 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg7ei64.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg7ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf4x7_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf2x7_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vluxseg7ei64_v_u64m1x7_tu(vuint64m1x7_t vd, const uint64_t *r return __riscv_vluxseg7ei64_v_u64m1x7_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x7_t test_vluxseg7ei64_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, co return __riscv_vluxseg7ei64_v_u64m1x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x7_t test_vluxseg7ei64_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, c return __riscv_vluxseg7ei64_v_u64m1x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg7ei8.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg7ei8.c index d176ef043..1c00edcf7 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg7ei8.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg7ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf4x7_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf2x7_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16m1x7_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vluxseg7ei8_v_u64m1x7_tu(vuint64m1x7_t vd, const uint64_t *rs return __riscv_vluxseg7ei8_v_u64m1x7_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf4x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf2x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16m1x7_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x7_t test_vluxseg7ei8_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, con return __riscv_vluxseg7ei8_v_u64m1x7_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf4x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf2x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16m1x7_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x7_t test_vluxseg7ei8_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, co return __riscv_vluxseg7ei8_v_u64m1x7_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf4x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16mf2x7_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_v_f16m1x7_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg8ei16.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg8ei16.c index f32f9d9e4..461435ef5 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg8ei16.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg8ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf4x8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf2x8_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vluxseg8ei16_v_u64m1x8_tu(vuint64m1x8_t vd, const uint64_t *r return __riscv_vluxseg8ei16_v_u64m1x8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x8_t test_vluxseg8ei16_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, co return __riscv_vluxseg8ei16_v_u64m1x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x8_t test_vluxseg8ei16_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, c return __riscv_vluxseg8ei16_v_u64m1x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg8ei32.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg8ei32.c index 3fe2a77d9..1c6c85f39 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg8ei32.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg8ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf4x8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf2x8_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vluxseg8ei32_v_u64m1x8_tu(vuint64m1x8_t vd, const uint64_t *r return __riscv_vluxseg8ei32_v_u64m1x8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x8_t test_vluxseg8ei32_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, co return __riscv_vluxseg8ei32_v_u64m1x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x8_t test_vluxseg8ei32_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, c return __riscv_vluxseg8ei32_v_u64m1x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg8ei64.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg8ei64.c index a6c967629..d6bd65884 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg8ei64.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg8ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf4x8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf2x8_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vluxseg8ei64_v_u64m1x8_tu(vuint64m1x8_t vd, const uint64_t *r return __riscv_vluxseg8ei64_v_u64m1x8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x8_t test_vluxseg8ei64_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, co return __riscv_vluxseg8ei64_v_u64m1x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x8_t test_vluxseg8ei64_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, c return __riscv_vluxseg8ei64_v_u64m1x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-api-tests/vluxseg8ei8.c b/auto-generated/policy_funcs/gnu-api-tests/vluxseg8ei8.c index 5c98f29cf..9cabf31e0 100644 --- a/auto-generated/policy_funcs/gnu-api-tests/vluxseg8ei8.c +++ b/auto-generated/policy_funcs/gnu-api-tests/vluxseg8ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf4x8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf2x8_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16m1x8_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vluxseg8ei8_v_u64m1x8_tu(vuint64m1x8_t vd, const uint64_t *rs return __riscv_vluxseg8ei8_v_u64m1x8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf4x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf2x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16m1x8_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x8_t test_vluxseg8ei8_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, con return __riscv_vluxseg8ei8_v_u64m1x8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf4x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf2x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16m1x8_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x8_t test_vluxseg8ei8_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, co return __riscv_vluxseg8ei8_v_u64m1x8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf4x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16mf2x8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_v_f16m1x8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vle16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vle16.c index 0bc5c9281..37bbe1aef 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vle16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vle16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vle16_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4_t test_vle16_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tu(vd, rs1, vl); } -vfloat16mf2_t test_vle16_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2_t test_vle16_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tu(vd, rs1, vl); } -vfloat16m1_t test_vle16_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1_t test_vle16_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tu(vd, rs1, vl); } -vfloat16m2_t test_vle16_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2_t test_vle16_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tu(vd, rs1, vl); } -vfloat16m4_t test_vle16_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m4_t test_vle16_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tu(vd, rs1, vl); } -vfloat16m8_t test_vle16_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, size_t vl) { +vfloat16m8_t test_vle16_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tu(vd, rs1, vl); } @@ -79,27 +79,27 @@ vuint16m8_t test_vle16_v_u16m8_tu(vuint16m8_t vd, const uint16_t *rs1, size_t vl return __riscv_vle16_tu(vd, rs1, vl); } -vfloat16mf4_t test_vle16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4_t test_vle16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tum(vm, vd, rs1, vl); } -vfloat16mf2_t test_vle16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2_t test_vle16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tum(vm, vd, rs1, vl); } -vfloat16m1_t test_vle16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1_t test_vle16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tum(vm, vd, rs1, vl); } -vfloat16m2_t test_vle16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2_t test_vle16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tum(vm, vd, rs1, vl); } -vfloat16m4_t test_vle16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m4_t test_vle16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tum(vm, vd, rs1, vl); } -vfloat16m8_t test_vle16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, size_t vl) { +vfloat16m8_t test_vle16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tum(vm, vd, rs1, vl); } @@ -151,27 +151,27 @@ vuint16m8_t test_vle16_v_u16m8_tum(vbool2_t vm, vuint16m8_t vd, const uint16_t * return __riscv_vle16_tum(vm, vd, rs1, vl); } -vfloat16mf4_t test_vle16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4_t test_vle16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tumu(vm, vd, rs1, vl); } -vfloat16mf2_t test_vle16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2_t test_vle16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tumu(vm, vd, rs1, vl); } -vfloat16m1_t test_vle16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1_t test_vle16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tumu(vm, vd, rs1, vl); } -vfloat16m2_t test_vle16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2_t test_vle16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tumu(vm, vd, rs1, vl); } -vfloat16m4_t test_vle16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m4_t test_vle16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tumu(vm, vd, rs1, vl); } -vfloat16m8_t test_vle16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, size_t vl) { +vfloat16m8_t test_vle16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tumu(vm, vd, rs1, vl); } @@ -223,27 +223,27 @@ vuint16m8_t test_vle16_v_u16m8_tumu(vbool2_t vm, vuint16m8_t vd, const uint16_t return __riscv_vle16_tumu(vm, vd, rs1, vl); } -vfloat16mf4_t test_vle16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4_t test_vle16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_mu(vm, vd, rs1, vl); } -vfloat16mf2_t test_vle16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2_t test_vle16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_mu(vm, vd, rs1, vl); } -vfloat16m1_t test_vle16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1_t test_vle16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_mu(vm, vd, rs1, vl); } -vfloat16m2_t test_vle16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2_t test_vle16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_mu(vm, vd, rs1, vl); } -vfloat16m4_t test_vle16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m4_t test_vle16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_mu(vm, vd, rs1, vl); } -vfloat16m8_t test_vle16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, size_t vl) { +vfloat16m8_t test_vle16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vle16ff.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vle16ff.c index 11a7e3281..13c733e3d 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vle16ff.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vle16ff.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vle16ff_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4_t test_vle16ff_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf2_t test_vle16ff_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2_t test_vle16ff_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m1_t test_vle16ff_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1_t test_vle16ff_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m2_t test_vle16ff_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2_t test_vle16ff_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m4_t test_vle16ff_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4_t test_vle16ff_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m8_t test_vle16ff_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m8_t test_vle16ff_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tu(vd, rs1, new_vl, vl); } @@ -79,27 +79,27 @@ vuint16m8_t test_vle16ff_v_u16m8_tu(vuint16m8_t vd, const uint16_t *rs1, size_t return __riscv_vle16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf4_t test_vle16ff_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4_t test_vle16ff_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf2_t test_vle16ff_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2_t test_vle16ff_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m1_t test_vle16ff_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1_t test_vle16ff_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m2_t test_vle16ff_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2_t test_vle16ff_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m4_t test_vle16ff_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4_t test_vle16ff_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m8_t test_vle16ff_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m8_t test_vle16ff_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tum(vm, vd, rs1, new_vl, vl); } @@ -151,27 +151,27 @@ vuint16m8_t test_vle16ff_v_u16m8_tum(vbool2_t vm, vuint16m8_t vd, const uint16_t return __riscv_vle16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf4_t test_vle16ff_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4_t test_vle16ff_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2_t test_vle16ff_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2_t test_vle16ff_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m1_t test_vle16ff_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1_t test_vle16ff_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m2_t test_vle16ff_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2_t test_vle16ff_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m4_t test_vle16ff_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4_t test_vle16ff_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m8_t test_vle16ff_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m8_t test_vle16ff_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tumu(vm, vd, rs1, new_vl, vl); } @@ -223,27 +223,27 @@ vuint16m8_t test_vle16ff_v_u16m8_tumu(vbool2_t vm, vuint16m8_t vd, const uint16_ return __riscv_vle16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf4_t test_vle16ff_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4_t test_vle16ff_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2_t test_vle16ff_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2_t test_vle16ff_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m1_t test_vle16ff_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1_t test_vle16ff_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m2_t test_vle16ff_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2_t test_vle16ff_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m4_t test_vle16ff_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4_t test_vle16ff_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m8_t test_vle16ff_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m8_t test_vle16ff_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxei16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxei16.c index 70c7f6cfb..37a432345 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxei16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxei16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei16_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei16_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei16_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vloxei16_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vloxei16_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vloxei16_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vloxei16_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_tu(vd, rs1, rs2, vl); } @@ -235,27 +235,27 @@ vuint64m8_t test_vloxei16_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, vuint1 return __riscv_vloxei16_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vloxei16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vloxei16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vloxei16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vloxei16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_tum(vm, vd, rs1, rs2, vl); } @@ -463,27 +463,27 @@ vuint64m8_t test_vloxei16_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, const uint64_ return __riscv_vloxei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vloxei16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vloxei16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vloxei16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vloxei16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_tumu(vm, vd, rs1, rs2, vl); } @@ -691,27 +691,27 @@ vuint64m8_t test_vloxei16_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, const uint64 return __riscv_vloxei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vloxei16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vloxei16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vloxei16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vloxei16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxei32.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxei32.c index 0fa8f5d65..5a3707663 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxei32.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei32_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei32_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei32_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei32_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vloxei32_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vloxei32_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_tu(vd, rs1, rs2, vl); } @@ -215,23 +215,23 @@ vuint64m8_t test_vloxei32_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, vuint3 return __riscv_vloxei32_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei32_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei32_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei32_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei32_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vloxei32_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vloxei32_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_tum(vm, vd, rs1, rs2, vl); } @@ -423,23 +423,23 @@ vuint64m8_t test_vloxei32_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, const uint64_ return __riscv_vloxei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei32_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei32_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei32_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei32_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vloxei32_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vloxei32_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_tumu(vm, vd, rs1, rs2, vl); } @@ -631,23 +631,23 @@ vuint64m8_t test_vloxei32_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, const uint64 return __riscv_vloxei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei32_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei32_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei32_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei32_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vloxei32_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vloxei32_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxei64.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxei64.c index 0f8759594..8aa482b5e 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxei64.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei64_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei64_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei64_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vloxei64_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vloxei64_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_tu(vd, rs1, rs2, vl); } @@ -183,19 +183,19 @@ vuint64m8_t test_vloxei64_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, vuint6 return __riscv_vloxei64_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei64_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei64_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei64_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vloxei64_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vloxei64_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_tum(vm, vd, rs1, rs2, vl); } @@ -359,19 +359,19 @@ vuint64m8_t test_vloxei64_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, const uint64_ return __riscv_vloxei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei64_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei64_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei64_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vloxei64_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vloxei64_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_tumu(vm, vd, rs1, rs2, vl); } @@ -535,19 +535,19 @@ vuint64m8_t test_vloxei64_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, const uint64 return __riscv_vloxei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei64_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei64_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei64_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vloxei64_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vloxei64_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxei8.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxei8.c index 83349f617..202cc0d54 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxei8.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxei8.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei8_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei8_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei8_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei8_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vloxei8_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vloxei8_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vloxei8_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_tu(vd, rs1, rs2, vl); } @@ -243,27 +243,27 @@ vuint64m8_t test_vloxei8_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, vuint8m return __riscv_vloxei8_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei8_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei8_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei8_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei8_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vloxei8_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vloxei8_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vloxei8_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_tum(vm, vd, rs1, rs2, vl); } @@ -479,27 +479,27 @@ vuint64m8_t test_vloxei8_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, const uint64_t return __riscv_vloxei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei8_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei8_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei8_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei8_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vloxei8_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vloxei8_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vloxei8_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_tumu(vm, vd, rs1, rs2, vl); } @@ -715,27 +715,27 @@ vuint64m8_t test_vloxei8_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, const uint64_ return __riscv_vloxei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vloxei8_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vloxei8_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vloxei8_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vloxei8_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vloxei8_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vloxei8_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vloxei8_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg2ei16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg2ei16.c index 5c08c02b9..9d691fc27 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg2ei16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg2ei16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tu(vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tu(vd, rs1, rs2, vl); } @@ -199,23 +199,23 @@ vuint64m4x2_t test_vloxseg2ei16_v_u64m4x2_tu(vuint64m4x2_t vd, const uint64_t *r return __riscv_vloxseg2ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tum(vm, vd, rs1, rs2, vl); } @@ -391,23 +391,23 @@ vuint64m4x2_t test_vloxseg2ei16_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, co return __riscv_vloxseg2ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -583,23 +583,23 @@ vuint64m4x2_t test_vloxseg2ei16_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, c return __riscv_vloxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg2ei32.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg2ei32.c index b2d240166..06a173c6e 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg2ei32.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg2ei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tu(vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tu(vd, rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m4x2_t test_vloxseg2ei32_v_u64m4x2_tu(vuint64m4x2_t vd, const uint64_t *r return __riscv_vloxseg2ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tum(vm, vd, rs1, rs2, vl); } @@ -375,23 +375,23 @@ vuint64m4x2_t test_vloxseg2ei32_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, co return __riscv_vloxseg2ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -559,23 +559,23 @@ vuint64m4x2_t test_vloxseg2ei32_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, c return __riscv_vloxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg2ei64.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg2ei64.c index 4b892ec8e..d6fd57361 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg2ei64.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg2ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tu(vd, rs1, rs2, vl); } @@ -171,19 +171,19 @@ vuint64m4x2_t test_vloxseg2ei64_v_u64m4x2_tu(vuint64m4x2_t vd, const uint64_t *r return __riscv_vloxseg2ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tum(vm, vd, rs1, rs2, vl); } @@ -335,19 +335,19 @@ vuint64m4x2_t test_vloxseg2ei64_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, co return __riscv_vloxseg2ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -499,19 +499,19 @@ vuint64m4x2_t test_vloxseg2ei64_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, c return __riscv_vloxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg2ei8.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg2ei8.c index 65d787474..07594b7f2 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg2ei8.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg2ei8.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tu(vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tu(vd, rs1, rs2, vl); } @@ -199,23 +199,23 @@ vuint64m4x2_t test_vloxseg2ei8_v_u64m4x2_tu(vuint64m4x2_t vd, const uint64_t *rs return __riscv_vloxseg2ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tum(vm, vd, rs1, rs2, vl); } @@ -391,23 +391,23 @@ vuint64m4x2_t test_vloxseg2ei8_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, con return __riscv_vloxseg2ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -583,23 +583,23 @@ vuint64m4x2_t test_vloxseg2ei8_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, co return __riscv_vloxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg3ei16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg3ei16.c index 89a840d55..ac9f3df90 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg3ei16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg3ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vloxseg3ei16_v_u64m2x3_tu(vuint64m2x3_t vd, const uint64_t *r return __riscv_vloxseg3ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x3_t test_vloxseg3ei16_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, co return __riscv_vloxseg3ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x3_t test_vloxseg3ei16_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, c return __riscv_vloxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg3ei32.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg3ei32.c index 8753dda9a..2793af9c1 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg3ei32.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg3ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vloxseg3ei32_v_u64m2x3_tu(vuint64m2x3_t vd, const uint64_t *r return __riscv_vloxseg3ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x3_t test_vloxseg3ei32_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, co return __riscv_vloxseg3ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x3_t test_vloxseg3ei32_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, c return __riscv_vloxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg3ei64.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg3ei64.c index 36ebf6f9b..5496a81aa 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg3ei64.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg3ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tu(vd, rs1, rs2, vl); } @@ -147,19 +147,19 @@ vuint64m2x3_t test_vloxseg3ei64_v_u64m2x3_tu(vuint64m2x3_t vd, const uint64_t *r return __riscv_vloxseg3ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tum(vm, vd, rs1, rs2, vl); } @@ -287,19 +287,19 @@ vuint64m2x3_t test_vloxseg3ei64_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, co return __riscv_vloxseg3ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -427,19 +427,19 @@ vuint64m2x3_t test_vloxseg3ei64_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, c return __riscv_vloxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg3ei8.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg3ei8.c index 65620fa26..4c1a1787b 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg3ei8.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg3ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vloxseg3ei8_v_u64m2x3_tu(vuint64m2x3_t vd, const uint64_t *rs return __riscv_vloxseg3ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x3_t test_vloxseg3ei8_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, con return __riscv_vloxseg3ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x3_t test_vloxseg3ei8_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, co return __riscv_vloxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg4ei16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg4ei16.c index 1d5ae58a5..0edda1389 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg4ei16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg4ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vloxseg4ei16_v_u64m2x4_tu(vuint64m2x4_t vd, const uint64_t *r return __riscv_vloxseg4ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x4_t test_vloxseg4ei16_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, co return __riscv_vloxseg4ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x4_t test_vloxseg4ei16_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, c return __riscv_vloxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg4ei32.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg4ei32.c index 6368af621..9bc463f00 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg4ei32.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg4ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vloxseg4ei32_v_u64m2x4_tu(vuint64m2x4_t vd, const uint64_t *r return __riscv_vloxseg4ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x4_t test_vloxseg4ei32_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, co return __riscv_vloxseg4ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x4_t test_vloxseg4ei32_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, c return __riscv_vloxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg4ei64.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg4ei64.c index d316faa4c..5efe6a662 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg4ei64.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg4ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tu(vd, rs1, rs2, vl); } @@ -147,19 +147,19 @@ vuint64m2x4_t test_vloxseg4ei64_v_u64m2x4_tu(vuint64m2x4_t vd, const uint64_t *r return __riscv_vloxseg4ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tum(vm, vd, rs1, rs2, vl); } @@ -287,19 +287,19 @@ vuint64m2x4_t test_vloxseg4ei64_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, co return __riscv_vloxseg4ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -427,19 +427,19 @@ vuint64m2x4_t test_vloxseg4ei64_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, c return __riscv_vloxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg4ei8.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg4ei8.c index 9897ac510..5c542b286 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg4ei8.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg4ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vloxseg4ei8_v_u64m2x4_tu(vuint64m2x4_t vd, const uint64_t *rs return __riscv_vloxseg4ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x4_t test_vloxseg4ei8_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, con return __riscv_vloxseg4ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x4_t test_vloxseg4ei8_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, co return __riscv_vloxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg5ei16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg5ei16.c index 3202474ac..aaeb3af17 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg5ei16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg5ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vloxseg5ei16_v_u64m1x5_tu(vuint64m1x5_t vd, const uint64_t *r return __riscv_vloxseg5ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x5_t test_vloxseg5ei16_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, co return __riscv_vloxseg5ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x5_t test_vloxseg5ei16_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, c return __riscv_vloxseg5ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg5ei32.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg5ei32.c index 674b230e1..8d4d03178 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg5ei32.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg5ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vloxseg5ei32_v_u64m1x5_tu(vuint64m1x5_t vd, const uint64_t *r return __riscv_vloxseg5ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x5_t test_vloxseg5ei32_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, co return __riscv_vloxseg5ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x5_t test_vloxseg5ei32_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, c return __riscv_vloxseg5ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg5ei64.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg5ei64.c index 641675095..dee3c0f20 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg5ei64.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg5ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vloxseg5ei64_v_u64m1x5_tu(vuint64m1x5_t vd, const uint64_t *r return __riscv_vloxseg5ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x5_t test_vloxseg5ei64_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, co return __riscv_vloxseg5ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x5_t test_vloxseg5ei64_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, c return __riscv_vloxseg5ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg5ei8.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg5ei8.c index b2c551ac4..a39e2b33c 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg5ei8.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg5ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vloxseg5ei8_v_u64m1x5_tu(vuint64m1x5_t vd, const uint64_t *rs return __riscv_vloxseg5ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x5_t test_vloxseg5ei8_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, con return __riscv_vloxseg5ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x5_t test_vloxseg5ei8_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, co return __riscv_vloxseg5ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg6ei16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg6ei16.c index c16ec7d9b..416563fe9 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg6ei16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg6ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vloxseg6ei16_v_u64m1x6_tu(vuint64m1x6_t vd, const uint64_t *r return __riscv_vloxseg6ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x6_t test_vloxseg6ei16_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, co return __riscv_vloxseg6ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x6_t test_vloxseg6ei16_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, c return __riscv_vloxseg6ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg6ei32.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg6ei32.c index 897810c09..1c4bcd024 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg6ei32.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg6ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vloxseg6ei32_v_u64m1x6_tu(vuint64m1x6_t vd, const uint64_t *r return __riscv_vloxseg6ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x6_t test_vloxseg6ei32_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, co return __riscv_vloxseg6ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x6_t test_vloxseg6ei32_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, c return __riscv_vloxseg6ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg6ei64.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg6ei64.c index 9a386a1bf..348912623 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg6ei64.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg6ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vloxseg6ei64_v_u64m1x6_tu(vuint64m1x6_t vd, const uint64_t *r return __riscv_vloxseg6ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x6_t test_vloxseg6ei64_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, co return __riscv_vloxseg6ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x6_t test_vloxseg6ei64_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, c return __riscv_vloxseg6ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg6ei8.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg6ei8.c index b7ebac408..98ad34da9 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg6ei8.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg6ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vloxseg6ei8_v_u64m1x6_tu(vuint64m1x6_t vd, const uint64_t *rs return __riscv_vloxseg6ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x6_t test_vloxseg6ei8_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, con return __riscv_vloxseg6ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x6_t test_vloxseg6ei8_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, co return __riscv_vloxseg6ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg7ei16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg7ei16.c index 2546881c1..0208bd6b9 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg7ei16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg7ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vloxseg7ei16_v_u64m1x7_tu(vuint64m1x7_t vd, const uint64_t *r return __riscv_vloxseg7ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x7_t test_vloxseg7ei16_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, co return __riscv_vloxseg7ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x7_t test_vloxseg7ei16_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, c return __riscv_vloxseg7ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg7ei32.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg7ei32.c index 799d06ce7..1b5947e3a 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg7ei32.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg7ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vloxseg7ei32_v_u64m1x7_tu(vuint64m1x7_t vd, const uint64_t *r return __riscv_vloxseg7ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x7_t test_vloxseg7ei32_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, co return __riscv_vloxseg7ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x7_t test_vloxseg7ei32_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, c return __riscv_vloxseg7ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg7ei64.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg7ei64.c index b82868cc0..290bfbbd0 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg7ei64.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg7ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vloxseg7ei64_v_u64m1x7_tu(vuint64m1x7_t vd, const uint64_t *r return __riscv_vloxseg7ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x7_t test_vloxseg7ei64_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, co return __riscv_vloxseg7ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x7_t test_vloxseg7ei64_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, c return __riscv_vloxseg7ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg7ei8.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg7ei8.c index 537f08408..fdaef5d5f 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg7ei8.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg7ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vloxseg7ei8_v_u64m1x7_tu(vuint64m1x7_t vd, const uint64_t *rs return __riscv_vloxseg7ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x7_t test_vloxseg7ei8_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, con return __riscv_vloxseg7ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x7_t test_vloxseg7ei8_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, co return __riscv_vloxseg7ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg8ei16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg8ei16.c index 5ef8ba21a..b9c1397cd 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg8ei16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg8ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vloxseg8ei16_v_u64m1x8_tu(vuint64m1x8_t vd, const uint64_t *r return __riscv_vloxseg8ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x8_t test_vloxseg8ei16_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, co return __riscv_vloxseg8ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x8_t test_vloxseg8ei16_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, c return __riscv_vloxseg8ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg8ei32.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg8ei32.c index f43d86bde..7786375cc 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg8ei32.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg8ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vloxseg8ei32_v_u64m1x8_tu(vuint64m1x8_t vd, const uint64_t *r return __riscv_vloxseg8ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x8_t test_vloxseg8ei32_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, co return __riscv_vloxseg8ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x8_t test_vloxseg8ei32_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, c return __riscv_vloxseg8ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg8ei64.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg8ei64.c index 58b295b02..49544233e 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg8ei64.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg8ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vloxseg8ei64_v_u64m1x8_tu(vuint64m1x8_t vd, const uint64_t *r return __riscv_vloxseg8ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x8_t test_vloxseg8ei64_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, co return __riscv_vloxseg8ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x8_t test_vloxseg8ei64_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, c return __riscv_vloxseg8ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg8ei8.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg8ei8.c index 9a094c310..21b1d3e43 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg8ei8.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vloxseg8ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vloxseg8ei8_v_u64m1x8_tu(vuint64m1x8_t vd, const uint64_t *rs return __riscv_vloxseg8ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x8_t test_vloxseg8ei8_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, con return __riscv_vloxseg8ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x8_t test_vloxseg8ei8_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, co return __riscv_vloxseg8ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlse16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlse16.c index 5f41fdcac..0b29ecb3b 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlse16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlse16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vlse16_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4_t test_vlse16_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vlse16_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2_t test_vlse16_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vlse16_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1_t test_vlse16_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vlse16_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2_t test_vlse16_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vlse16_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4_t test_vlse16_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vlse16_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m8_t test_vlse16_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tu(vd, rs1, rs2, vl); } @@ -79,27 +79,27 @@ vuint16m8_t test_vlse16_v_u16m8_tu(vuint16m8_t vd, const uint16_t *rs1, ptrdiff_ return __riscv_vlse16_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vlse16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4_t test_vlse16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vlse16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2_t test_vlse16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vlse16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1_t test_vlse16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vlse16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2_t test_vlse16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vlse16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4_t test_vlse16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vlse16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m8_t test_vlse16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tum(vm, vd, rs1, rs2, vl); } @@ -151,27 +151,27 @@ vuint16m8_t test_vlse16_v_u16m8_tum(vbool2_t vm, vuint16m8_t vd, const uint16_t return __riscv_vlse16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vlse16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4_t test_vlse16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vlse16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2_t test_vlse16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vlse16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1_t test_vlse16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vlse16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2_t test_vlse16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vlse16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4_t test_vlse16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vlse16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m8_t test_vlse16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tumu(vm, vd, rs1, rs2, vl); } @@ -223,27 +223,27 @@ vuint16m8_t test_vlse16_v_u16m8_tumu(vbool2_t vm, vuint16m8_t vd, const uint16_t return __riscv_vlse16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vlse16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4_t test_vlse16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vlse16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2_t test_vlse16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vlse16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1_t test_vlse16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vlse16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2_t test_vlse16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vlse16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4_t test_vlse16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vlse16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m8_t test_vlse16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg2e16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg2e16.c index 0439ee709..e4491dde8 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg2e16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg2e16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tu(vd, rs1, vl); } -vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tu(vd, rs1, vl); } -vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tu(vd, rs1, vl); } -vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tu(vd, rs1, vl); } -vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tu(vd, rs1, vl); } @@ -67,23 +67,23 @@ vuint16m4x2_t test_vlseg2e16_v_u16m4x2_tu(vuint16m4x2_t vd, const uint16_t *rs1, return __riscv_vlseg2e16_tu(vd, rs1, vl); } -vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tum(vm, vd, rs1, vl); } -vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tum(vm, vd, rs1, vl); } -vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tum(vm, vd, rs1, vl); } -vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tum(vm, vd, rs1, vl); } -vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tum(vm, vd, rs1, vl); } @@ -127,23 +127,23 @@ vuint16m4x2_t test_vlseg2e16_v_u16m4x2_tum(vbool4_t vm, vuint16m4x2_t vd, const return __riscv_vlseg2e16_tum(vm, vd, rs1, vl); } -vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tumu(vm, vd, rs1, vl); } -vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tumu(vm, vd, rs1, vl); } -vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tumu(vm, vd, rs1, vl); } -vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tumu(vm, vd, rs1, vl); } -vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tumu(vm, vd, rs1, vl); } @@ -187,23 +187,23 @@ vuint16m4x2_t test_vlseg2e16_v_u16m4x2_tumu(vbool4_t vm, vuint16m4x2_t vd, const return __riscv_vlseg2e16_tumu(vm, vd, rs1, vl); } -vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_mu(vm, vd, rs1, vl); } -vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_mu(vm, vd, rs1, vl); } -vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_mu(vm, vd, rs1, vl); } -vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_mu(vm, vd, rs1, vl); } -vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, size_t vl) { +vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg2e16ff.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg2e16ff.c index d5d939830..95fa6bfa0 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg2e16ff.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg2e16ff.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tu(vd, rs1, new_vl, vl); } @@ -67,23 +67,23 @@ vuint16m4x2_t test_vlseg2e16ff_v_u16m4x2_tu(vuint16m4x2_t vd, const uint16_t *rs return __riscv_vlseg2e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tum(vm, vd, rs1, new_vl, vl); } @@ -127,23 +127,23 @@ vuint16m4x2_t test_vlseg2e16ff_v_u16m4x2_tum(vbool4_t vm, vuint16m4x2_t vd, cons return __riscv_vlseg2e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tumu(vm, vd, rs1, new_vl, vl); } @@ -187,23 +187,23 @@ vuint16m4x2_t test_vlseg2e16ff_v_u16m4x2_tumu(vbool4_t vm, vuint16m4x2_t vd, con return __riscv_vlseg2e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg3e16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg3e16.c index f78fa8027..e11a1406e 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg3e16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg3e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tu(vd, rs1, vl); } -vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tu(vd, rs1, vl); } -vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tu(vd, rs1, vl); } -vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tu(vd, rs1, vl); } @@ -55,19 +55,19 @@ vuint16m2x3_t test_vlseg3e16_v_u16m2x3_tu(vuint16m2x3_t vd, const uint16_t *rs1, return __riscv_vlseg3e16_tu(vd, rs1, vl); } -vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tum(vm, vd, rs1, vl); } -vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tum(vm, vd, rs1, vl); } -vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tum(vm, vd, rs1, vl); } -vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tum(vm, vd, rs1, vl); } @@ -103,19 +103,19 @@ vuint16m2x3_t test_vlseg3e16_v_u16m2x3_tum(vbool8_t vm, vuint16m2x3_t vd, const return __riscv_vlseg3e16_tum(vm, vd, rs1, vl); } -vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tumu(vm, vd, rs1, vl); } -vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tumu(vm, vd, rs1, vl); } -vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tumu(vm, vd, rs1, vl); } -vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tumu(vm, vd, rs1, vl); } @@ -151,19 +151,19 @@ vuint16m2x3_t test_vlseg3e16_v_u16m2x3_tumu(vbool8_t vm, vuint16m2x3_t vd, const return __riscv_vlseg3e16_tumu(vm, vd, rs1, vl); } -vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_mu(vm, vd, rs1, vl); } -vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_mu(vm, vd, rs1, vl); } -vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_mu(vm, vd, rs1, vl); } -vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg3e16ff.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg3e16ff.c index 324ebf519..e9c5e3bc3 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg3e16ff.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg3e16ff.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tu(vd, rs1, new_vl, vl); } @@ -55,19 +55,19 @@ vuint16m2x3_t test_vlseg3e16ff_v_u16m2x3_tu(vuint16m2x3_t vd, const uint16_t *rs return __riscv_vlseg3e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tum(vm, vd, rs1, new_vl, vl); } @@ -103,19 +103,19 @@ vuint16m2x3_t test_vlseg3e16ff_v_u16m2x3_tum(vbool8_t vm, vuint16m2x3_t vd, cons return __riscv_vlseg3e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tumu(vm, vd, rs1, new_vl, vl); } @@ -151,19 +151,19 @@ vuint16m2x3_t test_vlseg3e16ff_v_u16m2x3_tumu(vbool8_t vm, vuint16m2x3_t vd, con return __riscv_vlseg3e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg4e16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg4e16.c index 2dd619c5f..27ce497f6 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg4e16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg4e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tu(vd, rs1, vl); } -vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tu(vd, rs1, vl); } -vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tu(vd, rs1, vl); } -vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tu(vd, rs1, vl); } @@ -55,19 +55,19 @@ vuint16m2x4_t test_vlseg4e16_v_u16m2x4_tu(vuint16m2x4_t vd, const uint16_t *rs1, return __riscv_vlseg4e16_tu(vd, rs1, vl); } -vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tum(vm, vd, rs1, vl); } -vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tum(vm, vd, rs1, vl); } -vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tum(vm, vd, rs1, vl); } -vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tum(vm, vd, rs1, vl); } @@ -103,19 +103,19 @@ vuint16m2x4_t test_vlseg4e16_v_u16m2x4_tum(vbool8_t vm, vuint16m2x4_t vd, const return __riscv_vlseg4e16_tum(vm, vd, rs1, vl); } -vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tumu(vm, vd, rs1, vl); } -vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tumu(vm, vd, rs1, vl); } -vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tumu(vm, vd, rs1, vl); } -vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tumu(vm, vd, rs1, vl); } @@ -151,19 +151,19 @@ vuint16m2x4_t test_vlseg4e16_v_u16m2x4_tumu(vbool8_t vm, vuint16m2x4_t vd, const return __riscv_vlseg4e16_tumu(vm, vd, rs1, vl); } -vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_mu(vm, vd, rs1, vl); } -vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_mu(vm, vd, rs1, vl); } -vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_mu(vm, vd, rs1, vl); } -vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, size_t vl) { +vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg4e16ff.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg4e16ff.c index e24aba5fc..a69315d54 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg4e16ff.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg4e16ff.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tu(vd, rs1, new_vl, vl); } @@ -55,19 +55,19 @@ vuint16m2x4_t test_vlseg4e16ff_v_u16m2x4_tu(vuint16m2x4_t vd, const uint16_t *rs return __riscv_vlseg4e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tum(vm, vd, rs1, new_vl, vl); } @@ -103,19 +103,19 @@ vuint16m2x4_t test_vlseg4e16ff_v_u16m2x4_tum(vbool8_t vm, vuint16m2x4_t vd, cons return __riscv_vlseg4e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tumu(vm, vd, rs1, new_vl, vl); } @@ -151,19 +151,19 @@ vuint16m2x4_t test_vlseg4e16ff_v_u16m2x4_tumu(vbool8_t vm, vuint16m2x4_t vd, con return __riscv_vlseg4e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg5e16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg5e16.c index c2a14a099..32aa75a7c 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg5e16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg5e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tu(vd, rs1, vl); } -vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tu(vd, rs1, vl); } -vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tu(vd, rs1, vl); } @@ -43,15 +43,15 @@ vuint16m1x5_t test_vlseg5e16_v_u16m1x5_tu(vuint16m1x5_t vd, const uint16_t *rs1, return __riscv_vlseg5e16_tu(vd, rs1, vl); } -vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tum(vm, vd, rs1, vl); } -vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tum(vm, vd, rs1, vl); } -vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tum(vm, vd, rs1, vl); } @@ -79,15 +79,15 @@ vuint16m1x5_t test_vlseg5e16_v_u16m1x5_tum(vbool16_t vm, vuint16m1x5_t vd, const return __riscv_vlseg5e16_tum(vm, vd, rs1, vl); } -vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tumu(vm, vd, rs1, vl); } -vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tumu(vm, vd, rs1, vl); } -vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tumu(vm, vd, rs1, vl); } @@ -115,15 +115,15 @@ vuint16m1x5_t test_vlseg5e16_v_u16m1x5_tumu(vbool16_t vm, vuint16m1x5_t vd, cons return __riscv_vlseg5e16_tumu(vm, vd, rs1, vl); } -vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_mu(vm, vd, rs1, vl); } -vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_mu(vm, vd, rs1, vl); } -vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg5e16ff.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg5e16ff.c index 5f73ae5c9..42167fcd3 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg5e16ff.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg5e16ff.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tu(vd, rs1, new_vl, vl); } @@ -43,15 +43,15 @@ vuint16m1x5_t test_vlseg5e16ff_v_u16m1x5_tu(vuint16m1x5_t vd, const uint16_t *rs return __riscv_vlseg5e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tum(vm, vd, rs1, new_vl, vl); } @@ -79,15 +79,15 @@ vuint16m1x5_t test_vlseg5e16ff_v_u16m1x5_tum(vbool16_t vm, vuint16m1x5_t vd, con return __riscv_vlseg5e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tumu(vm, vd, rs1, new_vl, vl); } @@ -115,15 +115,15 @@ vuint16m1x5_t test_vlseg5e16ff_v_u16m1x5_tumu(vbool16_t vm, vuint16m1x5_t vd, co return __riscv_vlseg5e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg6e16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg6e16.c index 91d9c9521..4e42ace5d 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg6e16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg6e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tu(vd, rs1, vl); } -vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tu(vd, rs1, vl); } -vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tu(vd, rs1, vl); } @@ -43,15 +43,15 @@ vuint16m1x6_t test_vlseg6e16_v_u16m1x6_tu(vuint16m1x6_t vd, const uint16_t *rs1, return __riscv_vlseg6e16_tu(vd, rs1, vl); } -vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tum(vm, vd, rs1, vl); } -vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tum(vm, vd, rs1, vl); } -vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tum(vm, vd, rs1, vl); } @@ -79,15 +79,15 @@ vuint16m1x6_t test_vlseg6e16_v_u16m1x6_tum(vbool16_t vm, vuint16m1x6_t vd, const return __riscv_vlseg6e16_tum(vm, vd, rs1, vl); } -vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tumu(vm, vd, rs1, vl); } -vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tumu(vm, vd, rs1, vl); } -vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tumu(vm, vd, rs1, vl); } @@ -115,15 +115,15 @@ vuint16m1x6_t test_vlseg6e16_v_u16m1x6_tumu(vbool16_t vm, vuint16m1x6_t vd, cons return __riscv_vlseg6e16_tumu(vm, vd, rs1, vl); } -vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_mu(vm, vd, rs1, vl); } -vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_mu(vm, vd, rs1, vl); } -vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg6e16ff.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg6e16ff.c index 24bf4c67b..edb85df8d 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg6e16ff.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg6e16ff.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tu(vd, rs1, new_vl, vl); } @@ -43,15 +43,15 @@ vuint16m1x6_t test_vlseg6e16ff_v_u16m1x6_tu(vuint16m1x6_t vd, const uint16_t *rs return __riscv_vlseg6e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tum(vm, vd, rs1, new_vl, vl); } @@ -79,15 +79,15 @@ vuint16m1x6_t test_vlseg6e16ff_v_u16m1x6_tum(vbool16_t vm, vuint16m1x6_t vd, con return __riscv_vlseg6e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tumu(vm, vd, rs1, new_vl, vl); } @@ -115,15 +115,15 @@ vuint16m1x6_t test_vlseg6e16ff_v_u16m1x6_tumu(vbool16_t vm, vuint16m1x6_t vd, co return __riscv_vlseg6e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg7e16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg7e16.c index 0e72d5a30..58e6eaad0 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg7e16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg7e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tu(vd, rs1, vl); } -vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tu(vd, rs1, vl); } -vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tu(vd, rs1, vl); } @@ -43,15 +43,15 @@ vuint16m1x7_t test_vlseg7e16_v_u16m1x7_tu(vuint16m1x7_t vd, const uint16_t *rs1, return __riscv_vlseg7e16_tu(vd, rs1, vl); } -vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tum(vm, vd, rs1, vl); } -vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tum(vm, vd, rs1, vl); } -vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tum(vm, vd, rs1, vl); } @@ -79,15 +79,15 @@ vuint16m1x7_t test_vlseg7e16_v_u16m1x7_tum(vbool16_t vm, vuint16m1x7_t vd, const return __riscv_vlseg7e16_tum(vm, vd, rs1, vl); } -vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tumu(vm, vd, rs1, vl); } -vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tumu(vm, vd, rs1, vl); } -vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tumu(vm, vd, rs1, vl); } @@ -115,15 +115,15 @@ vuint16m1x7_t test_vlseg7e16_v_u16m1x7_tumu(vbool16_t vm, vuint16m1x7_t vd, cons return __riscv_vlseg7e16_tumu(vm, vd, rs1, vl); } -vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_mu(vm, vd, rs1, vl); } -vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_mu(vm, vd, rs1, vl); } -vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg7e16ff.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg7e16ff.c index 92a4b9b19..5668b461a 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg7e16ff.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg7e16ff.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tu(vd, rs1, new_vl, vl); } @@ -43,15 +43,15 @@ vuint16m1x7_t test_vlseg7e16ff_v_u16m1x7_tu(vuint16m1x7_t vd, const uint16_t *rs return __riscv_vlseg7e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tum(vm, vd, rs1, new_vl, vl); } @@ -79,15 +79,15 @@ vuint16m1x7_t test_vlseg7e16ff_v_u16m1x7_tum(vbool16_t vm, vuint16m1x7_t vd, con return __riscv_vlseg7e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tumu(vm, vd, rs1, new_vl, vl); } @@ -115,15 +115,15 @@ vuint16m1x7_t test_vlseg7e16ff_v_u16m1x7_tumu(vbool16_t vm, vuint16m1x7_t vd, co return __riscv_vlseg7e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg8e16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg8e16.c index dc1251c5a..51b6f84b3 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg8e16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg8e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tu(vd, rs1, vl); } -vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tu(vd, rs1, vl); } -vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tu(vd, rs1, vl); } @@ -43,15 +43,15 @@ vuint16m1x8_t test_vlseg8e16_v_u16m1x8_tu(vuint16m1x8_t vd, const uint16_t *rs1, return __riscv_vlseg8e16_tu(vd, rs1, vl); } -vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tum(vm, vd, rs1, vl); } -vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tum(vm, vd, rs1, vl); } -vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tum(vm, vd, rs1, vl); } @@ -79,15 +79,15 @@ vuint16m1x8_t test_vlseg8e16_v_u16m1x8_tum(vbool16_t vm, vuint16m1x8_t vd, const return __riscv_vlseg8e16_tum(vm, vd, rs1, vl); } -vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tumu(vm, vd, rs1, vl); } -vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tumu(vm, vd, rs1, vl); } -vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tumu(vm, vd, rs1, vl); } @@ -115,15 +115,15 @@ vuint16m1x8_t test_vlseg8e16_v_u16m1x8_tumu(vbool16_t vm, vuint16m1x8_t vd, cons return __riscv_vlseg8e16_tumu(vm, vd, rs1, vl); } -vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_mu(vm, vd, rs1, vl); } -vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_mu(vm, vd, rs1, vl); } -vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, size_t vl) { +vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg8e16ff.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg8e16ff.c index 4ed539fd1..2e4fd4af6 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg8e16ff.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlseg8e16ff.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tu(vd, rs1, new_vl, vl); } @@ -43,15 +43,15 @@ vuint16m1x8_t test_vlseg8e16ff_v_u16m1x8_tu(vuint16m1x8_t vd, const uint16_t *rs return __riscv_vlseg8e16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tum(vm, vd, rs1, new_vl, vl); } @@ -79,15 +79,15 @@ vuint16m1x8_t test_vlseg8e16ff_v_u16m1x8_tum(vbool16_t vm, vuint16m1x8_t vd, con return __riscv_vlseg8e16ff_tum(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tumu(vm, vd, rs1, new_vl, vl); } @@ -115,15 +115,15 @@ vuint16m1x8_t test_vlseg8e16ff_v_u16m1x8_tumu(vbool16_t vm, vuint16m1x8_t vd, co return __riscv_vlseg8e16ff_tumu(vm, vd, rs1, new_vl, vl); } -vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_mu(vm, vd, rs1, new_vl, vl); } -vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, size_t *new_vl, size_t vl) { +vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg2e16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg2e16.c index f21b94d80..fef84879d 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg2e16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg2e16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tu(vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tu(vd, rs1, rs2, vl); } @@ -67,23 +67,23 @@ vuint16m4x2_t test_vlsseg2e16_v_u16m4x2_tu(vuint16m4x2_t vd, const uint16_t *rs1 return __riscv_vlsseg2e16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tum(vm, vd, rs1, rs2, vl); } @@ -127,23 +127,23 @@ vuint16m4x2_t test_vlsseg2e16_v_u16m4x2_tum(vbool4_t vm, vuint16m4x2_t vd, const return __riscv_vlsseg2e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tumu(vm, vd, rs1, rs2, vl); } @@ -187,23 +187,23 @@ vuint16m4x2_t test_vlsseg2e16_v_u16m4x2_tumu(vbool4_t vm, vuint16m4x2_t vd, cons return __riscv_vlsseg2e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg3e16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg3e16.c index a9e512398..881844fc9 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg3e16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg3e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tu(vd, rs1, rs2, vl); } @@ -55,19 +55,19 @@ vuint16m2x3_t test_vlsseg3e16_v_u16m2x3_tu(vuint16m2x3_t vd, const uint16_t *rs1 return __riscv_vlsseg3e16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tum(vm, vd, rs1, rs2, vl); } @@ -103,19 +103,19 @@ vuint16m2x3_t test_vlsseg3e16_v_u16m2x3_tum(vbool8_t vm, vuint16m2x3_t vd, const return __riscv_vlsseg3e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tumu(vm, vd, rs1, rs2, vl); } @@ -151,19 +151,19 @@ vuint16m2x3_t test_vlsseg3e16_v_u16m2x3_tumu(vbool8_t vm, vuint16m2x3_t vd, cons return __riscv_vlsseg3e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg4e16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg4e16.c index ccc63bb98..84fd4e7dd 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg4e16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg4e16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tu(vd, rs1, rs2, vl); } @@ -55,19 +55,19 @@ vuint16m2x4_t test_vlsseg4e16_v_u16m2x4_tu(vuint16m2x4_t vd, const uint16_t *rs1 return __riscv_vlsseg4e16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tum(vm, vd, rs1, rs2, vl); } @@ -103,19 +103,19 @@ vuint16m2x4_t test_vlsseg4e16_v_u16m2x4_tum(vbool8_t vm, vuint16m2x4_t vd, const return __riscv_vlsseg4e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tumu(vm, vd, rs1, rs2, vl); } @@ -151,19 +151,19 @@ vuint16m2x4_t test_vlsseg4e16_v_u16m2x4_tumu(vbool8_t vm, vuint16m2x4_t vd, cons return __riscv_vlsseg4e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg5e16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg5e16.c index 8e6363a5c..55e5b958c 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg5e16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg5e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tu(vd, rs1, rs2, vl); } @@ -43,15 +43,15 @@ vuint16m1x5_t test_vlsseg5e16_v_u16m1x5_tu(vuint16m1x5_t vd, const uint16_t *rs1 return __riscv_vlsseg5e16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tum(vm, vd, rs1, rs2, vl); } @@ -79,15 +79,15 @@ vuint16m1x5_t test_vlsseg5e16_v_u16m1x5_tum(vbool16_t vm, vuint16m1x5_t vd, cons return __riscv_vlsseg5e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tumu(vm, vd, rs1, rs2, vl); } @@ -115,15 +115,15 @@ vuint16m1x5_t test_vlsseg5e16_v_u16m1x5_tumu(vbool16_t vm, vuint16m1x5_t vd, con return __riscv_vlsseg5e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg6e16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg6e16.c index 0b8482053..dbf1bcd5f 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg6e16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg6e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tu(vd, rs1, rs2, vl); } @@ -43,15 +43,15 @@ vuint16m1x6_t test_vlsseg6e16_v_u16m1x6_tu(vuint16m1x6_t vd, const uint16_t *rs1 return __riscv_vlsseg6e16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tum(vm, vd, rs1, rs2, vl); } @@ -79,15 +79,15 @@ vuint16m1x6_t test_vlsseg6e16_v_u16m1x6_tum(vbool16_t vm, vuint16m1x6_t vd, cons return __riscv_vlsseg6e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tumu(vm, vd, rs1, rs2, vl); } @@ -115,15 +115,15 @@ vuint16m1x6_t test_vlsseg6e16_v_u16m1x6_tumu(vbool16_t vm, vuint16m1x6_t vd, con return __riscv_vlsseg6e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg7e16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg7e16.c index 46abcf13a..5db18c30d 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg7e16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg7e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tu(vd, rs1, rs2, vl); } @@ -43,15 +43,15 @@ vuint16m1x7_t test_vlsseg7e16_v_u16m1x7_tu(vuint16m1x7_t vd, const uint16_t *rs1 return __riscv_vlsseg7e16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tum(vm, vd, rs1, rs2, vl); } @@ -79,15 +79,15 @@ vuint16m1x7_t test_vlsseg7e16_v_u16m1x7_tum(vbool16_t vm, vuint16m1x7_t vd, cons return __riscv_vlsseg7e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tumu(vm, vd, rs1, rs2, vl); } @@ -115,15 +115,15 @@ vuint16m1x7_t test_vlsseg7e16_v_u16m1x7_tumu(vbool16_t vm, vuint16m1x7_t vd, con return __riscv_vlsseg7e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg8e16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg8e16.c index d0732e1c5..33a532702 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg8e16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vlsseg8e16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tu(vd, rs1, rs2, vl); } @@ -43,15 +43,15 @@ vuint16m1x8_t test_vlsseg8e16_v_u16m1x8_tu(vuint16m1x8_t vd, const uint16_t *rs1 return __riscv_vlsseg8e16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tum(vm, vd, rs1, rs2, vl); } @@ -79,15 +79,15 @@ vuint16m1x8_t test_vlsseg8e16_v_u16m1x8_tum(vbool16_t vm, vuint16m1x8_t vd, cons return __riscv_vlsseg8e16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tumu(vm, vd, rs1, rs2, vl); } @@ -115,15 +115,15 @@ vuint16m1x8_t test_vlsseg8e16_v_u16m1x8_tumu(vbool16_t vm, vuint16m1x8_t vd, con return __riscv_vlsseg8e16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, ptrdiff_t rs2, size_t vl) { +vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxei16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxei16.c index a7addac74..d9a789f5b 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxei16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxei16.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei16_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei16_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei16_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vluxei16_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vluxei16_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vluxei16_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vluxei16_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_tu(vd, rs1, rs2, vl); } @@ -235,27 +235,27 @@ vuint64m8_t test_vluxei16_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, vuint1 return __riscv_vluxei16_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vluxei16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vluxei16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vluxei16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vluxei16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_tum(vm, vd, rs1, rs2, vl); } @@ -463,27 +463,27 @@ vuint64m8_t test_vluxei16_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, const uint64_ return __riscv_vluxei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vluxei16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vluxei16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vluxei16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vluxei16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_tumu(vm, vd, rs1, rs2, vl); } @@ -691,27 +691,27 @@ vuint64m8_t test_vluxei16_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, const uint64 return __riscv_vluxei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1_t test_vluxei16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2_t test_vluxei16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4_t test_vluxei16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint16m8_t rs2, size_t vl) { +vfloat16m8_t test_vluxei16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxei32.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxei32.c index 886ff0df0..3b2b6b2db 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxei32.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei32_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei32_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei32_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei32_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vluxei32_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vluxei32_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_tu(vd, rs1, rs2, vl); } @@ -215,23 +215,23 @@ vuint64m8_t test_vluxei32_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, vuint3 return __riscv_vluxei32_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei32_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei32_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei32_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei32_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vluxei32_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vluxei32_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_tum(vm, vd, rs1, rs2, vl); } @@ -423,23 +423,23 @@ vuint64m8_t test_vluxei32_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, const uint64_ return __riscv_vluxei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei32_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei32_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei32_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei32_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vluxei32_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vluxei32_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_tumu(vm, vd, rs1, rs2, vl); } @@ -631,23 +631,23 @@ vuint64m8_t test_vluxei32_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, const uint64 return __riscv_vluxei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei32_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei32_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei32_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei32_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2_t test_vluxei32_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4_t test_vluxei32_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxei64.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxei64.c index c81589e6e..d91e0e77c 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxei64.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei64_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei64_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei64_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vluxei64_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vluxei64_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_tu(vd, rs1, rs2, vl); } @@ -183,19 +183,19 @@ vuint64m8_t test_vluxei64_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, vuint6 return __riscv_vluxei64_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei64_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei64_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei64_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vluxei64_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vluxei64_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_tum(vm, vd, rs1, rs2, vl); } @@ -359,19 +359,19 @@ vuint64m8_t test_vluxei64_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, const uint64_ return __riscv_vluxei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei64_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei64_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei64_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vluxei64_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vluxei64_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_tumu(vm, vd, rs1, rs2, vl); } @@ -535,19 +535,19 @@ vuint64m8_t test_vluxei64_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, const uint64 return __riscv_vluxei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei64_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei64_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei64_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1_t test_vluxei64_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2_t test_vluxei64_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxei8.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxei8.c index fa71063e2..21b11dd16 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxei8.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxei8.c @@ -7,27 +7,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei8_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei8_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei8_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei8_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vluxei8_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vluxei8_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vluxei8_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_tu(vd, rs1, rs2, vl); } @@ -243,27 +243,27 @@ vuint64m8_t test_vluxei8_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, vuint8m return __riscv_vluxei8_tu(vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei8_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei8_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei8_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei8_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vluxei8_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vluxei8_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vluxei8_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_tum(vm, vd, rs1, rs2, vl); } @@ -479,27 +479,27 @@ vuint64m8_t test_vluxei8_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, const uint64_t return __riscv_vluxei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei8_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei8_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei8_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei8_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vluxei8_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vluxei8_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vluxei8_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_tumu(vm, vd, rs1, rs2, vl); } @@ -715,27 +715,27 @@ vuint64m8_t test_vluxei8_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, const uint64_ return __riscv_vluxei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4_t test_vluxei8_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4_t test_vluxei8_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2_t test_vluxei8_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1_t test_vluxei8_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2_t test_vluxei8_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4_t test_vluxei8_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const float16_t *rs1, vuint8m4_t rs2, size_t vl) { +vfloat16m8_t test_vluxei8_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg2ei16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg2ei16.c index 446b81a9b..d2271b4ca 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg2ei16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg2ei16.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tu(vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tu(vd, rs1, rs2, vl); } @@ -199,23 +199,23 @@ vuint64m4x2_t test_vluxseg2ei16_v_u64m4x2_tu(vuint64m4x2_t vd, const uint64_t *r return __riscv_vluxseg2ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tum(vm, vd, rs1, rs2, vl); } @@ -391,23 +391,23 @@ vuint64m4x2_t test_vluxseg2ei16_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, co return __riscv_vluxseg2ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -583,23 +583,23 @@ vuint64m4x2_t test_vluxseg2ei16_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, c return __riscv_vluxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint16m4_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg2ei32.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg2ei32.c index 0d3ac7933..9abe35836 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg2ei32.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg2ei32.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tu(vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tu(vd, rs1, rs2, vl); } @@ -191,23 +191,23 @@ vuint64m4x2_t test_vluxseg2ei32_v_u64m4x2_tu(vuint64m4x2_t vd, const uint64_t *r return __riscv_vluxseg2ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tum(vm, vd, rs1, rs2, vl); } @@ -375,23 +375,23 @@ vuint64m4x2_t test_vluxseg2ei32_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, co return __riscv_vluxseg2ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -559,23 +559,23 @@ vuint64m4x2_t test_vluxseg2ei32_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, c return __riscv_vluxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint32m8_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg2ei64.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg2ei64.c index fb60da798..4f552b428 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg2ei64.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg2ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tu(vd, rs1, rs2, vl); } @@ -171,19 +171,19 @@ vuint64m4x2_t test_vluxseg2ei64_v_u64m4x2_tu(vuint64m4x2_t vd, const uint64_t *r return __riscv_vluxseg2ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tum(vm, vd, rs1, rs2, vl); } @@ -335,19 +335,19 @@ vuint64m4x2_t test_vluxseg2ei64_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, co return __riscv_vluxseg2ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -499,19 +499,19 @@ vuint64m4x2_t test_vluxseg2ei64_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, c return __riscv_vluxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg2ei8.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg2ei8.c index 1a3227e22..efb2e9839 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg2ei8.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg2ei8.c @@ -7,23 +7,23 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tu(vfloat16mf4x2_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tu(vfloat16mf2x2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tu(vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tu(vfloat16m1x2_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tu(vfloat16m1x2_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tu(vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tu(vfloat16m2x2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tu(vfloat16m2x2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tu(vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tu(vfloat16m4x2_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tu(vfloat16m4x2_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tu(vd, rs1, rs2, vl); } @@ -199,23 +199,23 @@ vuint64m4x2_t test_vluxseg2ei8_v_u64m4x2_tu(vuint64m4x2_t vd, const uint64_t *rs return __riscv_vluxseg2ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tum(vm, vd, rs1, rs2, vl); } @@ -391,23 +391,23 @@ vuint64m4x2_t test_vluxseg2ei8_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, con return __riscv_vluxseg2ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -583,23 +583,23 @@ vuint64m4x2_t test_vluxseg2ei8_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, co return __riscv_vluxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const float16_t *rs1, vuint8m2_t rs2, size_t vl) { +vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg3ei16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg3ei16.c index 0ab5cb46b..1880fe4f8 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg3ei16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg3ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vluxseg3ei16_v_u64m2x3_tu(vuint64m2x3_t vd, const uint64_t *r return __riscv_vluxseg3ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x3_t test_vluxseg3ei16_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, co return __riscv_vluxseg3ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x3_t test_vluxseg3ei16_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, c return __riscv_vluxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg3ei32.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg3ei32.c index 3acfc2613..a60716291 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg3ei32.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg3ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vluxseg3ei32_v_u64m2x3_tu(vuint64m2x3_t vd, const uint64_t *r return __riscv_vluxseg3ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x3_t test_vluxseg3ei32_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, co return __riscv_vluxseg3ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x3_t test_vluxseg3ei32_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, c return __riscv_vluxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg3ei64.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg3ei64.c index a310f631f..c3917ee90 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg3ei64.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg3ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tu(vd, rs1, rs2, vl); } @@ -147,19 +147,19 @@ vuint64m2x3_t test_vluxseg3ei64_v_u64m2x3_tu(vuint64m2x3_t vd, const uint64_t *r return __riscv_vluxseg3ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tum(vm, vd, rs1, rs2, vl); } @@ -287,19 +287,19 @@ vuint64m2x3_t test_vluxseg3ei64_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, co return __riscv_vluxseg3ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -427,19 +427,19 @@ vuint64m2x3_t test_vluxseg3ei64_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, c return __riscv_vluxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg3ei8.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg3ei8.c index 0ea602793..19cf9c90d 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg3ei8.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg3ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tu(vfloat16mf4x3_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tu(vfloat16mf2x3_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tu(vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tu(vfloat16m1x3_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tu(vfloat16m1x3_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tu(vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tu(vfloat16m2x3_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tu(vfloat16m2x3_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x3_t test_vluxseg3ei8_v_u64m2x3_tu(vuint64m2x3_t vd, const uint64_t *rs return __riscv_vluxseg3ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x3_t test_vluxseg3ei8_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, con return __riscv_vluxseg3ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x3_t test_vluxseg3ei8_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, co return __riscv_vluxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg4ei16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg4ei16.c index 696a2a076..3837a879b 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg4ei16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg4ei16.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vluxseg4ei16_v_u64m2x4_tu(vuint64m2x4_t vd, const uint64_t *r return __riscv_vluxseg4ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x4_t test_vluxseg4ei16_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, co return __riscv_vluxseg4ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x4_t test_vluxseg4ei16_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, c return __riscv_vluxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint16m2_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg4ei32.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg4ei32.c index 9639bf78f..a384790d8 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg4ei32.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg4ei32.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vluxseg4ei32_v_u64m2x4_tu(vuint64m2x4_t vd, const uint64_t *r return __riscv_vluxseg4ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x4_t test_vluxseg4ei32_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, co return __riscv_vluxseg4ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x4_t test_vluxseg4ei32_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, c return __riscv_vluxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint32m4_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg4ei64.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg4ei64.c index b522b9392..dce29f0bf 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg4ei64.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg4ei64.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tu(vd, rs1, rs2, vl); } @@ -147,19 +147,19 @@ vuint64m2x4_t test_vluxseg4ei64_v_u64m2x4_tu(vuint64m2x4_t vd, const uint64_t *r return __riscv_vluxseg4ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tum(vm, vd, rs1, rs2, vl); } @@ -287,19 +287,19 @@ vuint64m2x4_t test_vluxseg4ei64_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, co return __riscv_vluxseg4ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -427,19 +427,19 @@ vuint64m2x4_t test_vluxseg4ei64_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, c return __riscv_vluxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint64m8_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg4ei8.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg4ei8.c index 2cb735a95..8fef91913 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg4ei8.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg4ei8.c @@ -7,19 +7,19 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tu(vfloat16mf4x4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tu(vfloat16mf2x4_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tu(vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tu(vfloat16m1x4_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tu(vfloat16m1x4_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tu(vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tu(vfloat16m2x4_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tu(vfloat16m2x4_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tu(vd, rs1, rs2, vl); } @@ -155,19 +155,19 @@ vuint64m2x4_t test_vluxseg4ei8_v_u64m2x4_tu(vuint64m2x4_t vd, const uint64_t *rs return __riscv_vluxseg4ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tum(vm, vd, rs1, rs2, vl); } @@ -303,19 +303,19 @@ vuint64m2x4_t test_vluxseg4ei8_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, con return __riscv_vluxseg4ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -451,19 +451,19 @@ vuint64m2x4_t test_vluxseg4ei8_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, co return __riscv_vluxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const float16_t *rs1, vuint8m1_t rs2, size_t vl) { +vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg5ei16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg5ei16.c index 881751b0f..bb3327747 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg5ei16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg5ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vluxseg5ei16_v_u64m1x5_tu(vuint64m1x5_t vd, const uint64_t *r return __riscv_vluxseg5ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x5_t test_vluxseg5ei16_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, co return __riscv_vluxseg5ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x5_t test_vluxseg5ei16_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, c return __riscv_vluxseg5ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg5ei32.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg5ei32.c index 2bdfb3a9f..784e518fa 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg5ei32.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg5ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vluxseg5ei32_v_u64m1x5_tu(vuint64m1x5_t vd, const uint64_t *r return __riscv_vluxseg5ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x5_t test_vluxseg5ei32_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, co return __riscv_vluxseg5ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x5_t test_vluxseg5ei32_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, c return __riscv_vluxseg5ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg5ei64.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg5ei64.c index 13ef31d73..ef564ff59 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg5ei64.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg5ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vluxseg5ei64_v_u64m1x5_tu(vuint64m1x5_t vd, const uint64_t *r return __riscv_vluxseg5ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x5_t test_vluxseg5ei64_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, co return __riscv_vluxseg5ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x5_t test_vluxseg5ei64_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, c return __riscv_vluxseg5ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg5ei8.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg5ei8.c index 9272a1fc5..d09f366cc 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg5ei8.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg5ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tu(vfloat16mf4x5_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tu(vfloat16mf2x5_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tu(vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tu(vfloat16m1x5_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tu(vfloat16m1x5_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x5_t test_vluxseg5ei8_v_u64m1x5_tu(vuint64m1x5_t vd, const uint64_t *rs return __riscv_vluxseg5ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x5_t test_vluxseg5ei8_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, con return __riscv_vluxseg5ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x5_t test_vluxseg5ei8_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, co return __riscv_vluxseg5ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg6ei16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg6ei16.c index 64a59e4ed..92f7ba225 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg6ei16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg6ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vluxseg6ei16_v_u64m1x6_tu(vuint64m1x6_t vd, const uint64_t *r return __riscv_vluxseg6ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x6_t test_vluxseg6ei16_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, co return __riscv_vluxseg6ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x6_t test_vluxseg6ei16_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, c return __riscv_vluxseg6ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg6ei32.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg6ei32.c index ff10104c0..f6a38e7c0 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg6ei32.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg6ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vluxseg6ei32_v_u64m1x6_tu(vuint64m1x6_t vd, const uint64_t *r return __riscv_vluxseg6ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x6_t test_vluxseg6ei32_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, co return __riscv_vluxseg6ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x6_t test_vluxseg6ei32_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, c return __riscv_vluxseg6ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg6ei64.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg6ei64.c index 9f38b8921..22a803249 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg6ei64.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg6ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vluxseg6ei64_v_u64m1x6_tu(vuint64m1x6_t vd, const uint64_t *r return __riscv_vluxseg6ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x6_t test_vluxseg6ei64_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, co return __riscv_vluxseg6ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x6_t test_vluxseg6ei64_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, c return __riscv_vluxseg6ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg6ei8.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg6ei8.c index 8424f3633..4d940e57d 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg6ei8.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg6ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tu(vfloat16mf4x6_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tu(vfloat16mf2x6_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tu(vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tu(vfloat16m1x6_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tu(vfloat16m1x6_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x6_t test_vluxseg6ei8_v_u64m1x6_tu(vuint64m1x6_t vd, const uint64_t *rs return __riscv_vluxseg6ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x6_t test_vluxseg6ei8_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, con return __riscv_vluxseg6ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x6_t test_vluxseg6ei8_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, co return __riscv_vluxseg6ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg7ei16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg7ei16.c index a8207034a..902606ad8 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg7ei16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg7ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vluxseg7ei16_v_u64m1x7_tu(vuint64m1x7_t vd, const uint64_t *r return __riscv_vluxseg7ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x7_t test_vluxseg7ei16_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, co return __riscv_vluxseg7ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x7_t test_vluxseg7ei16_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, c return __riscv_vluxseg7ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg7ei32.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg7ei32.c index 699ff83c0..ed4d5c86e 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg7ei32.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg7ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vluxseg7ei32_v_u64m1x7_tu(vuint64m1x7_t vd, const uint64_t *r return __riscv_vluxseg7ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x7_t test_vluxseg7ei32_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, co return __riscv_vluxseg7ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x7_t test_vluxseg7ei32_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, c return __riscv_vluxseg7ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg7ei64.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg7ei64.c index 6a8dd5cb2..c877e261e 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg7ei64.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg7ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vluxseg7ei64_v_u64m1x7_tu(vuint64m1x7_t vd, const uint64_t *r return __riscv_vluxseg7ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x7_t test_vluxseg7ei64_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, co return __riscv_vluxseg7ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x7_t test_vluxseg7ei64_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, c return __riscv_vluxseg7ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg7ei8.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg7ei8.c index 0d7c4a7ec..3796a5190 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg7ei8.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg7ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tu(vfloat16mf4x7_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tu(vfloat16mf2x7_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tu(vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tu(vfloat16m1x7_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tu(vfloat16m1x7_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x7_t test_vluxseg7ei8_v_u64m1x7_tu(vuint64m1x7_t vd, const uint64_t *rs return __riscv_vluxseg7ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x7_t test_vluxseg7ei8_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, con return __riscv_vluxseg7ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x7_t test_vluxseg7ei8_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, co return __riscv_vluxseg7ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg8ei16.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg8ei16.c index e56bdd64f..1f5b6370d 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg8ei16.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg8ei16.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vluxseg8ei16_v_u64m1x8_tu(vuint64m1x8_t vd, const uint64_t *r return __riscv_vluxseg8ei16_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x8_t test_vluxseg8ei16_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, co return __riscv_vluxseg8ei16_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x8_t test_vluxseg8ei16_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, c return __riscv_vluxseg8ei16_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint16mf4_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint16mf2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint16m1_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg8ei32.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg8ei32.c index 71d502972..7371f1259 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg8ei32.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg8ei32.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vluxseg8ei32_v_u64m1x8_tu(vuint64m1x8_t vd, const uint64_t *r return __riscv_vluxseg8ei32_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x8_t test_vluxseg8ei32_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, co return __riscv_vluxseg8ei32_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x8_t test_vluxseg8ei32_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, c return __riscv_vluxseg8ei32_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint32mf2_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint32m1_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint32m2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg8ei64.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg8ei64.c index 95cb1d090..814f768be 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg8ei64.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg8ei64.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vluxseg8ei64_v_u64m1x8_tu(vuint64m1x8_t vd, const uint64_t *r return __riscv_vluxseg8ei64_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x8_t test_vluxseg8ei64_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, co return __riscv_vluxseg8ei64_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x8_t test_vluxseg8ei64_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, c return __riscv_vluxseg8ei64_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint64m1_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint64m2_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint64m4_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg8ei8.c b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg8ei8.c index de21c211a..45d1616a6 100644 --- a/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg8ei8.c +++ b/auto-generated/policy_funcs/gnu-overloaded-tests/vluxseg8ei8.c @@ -7,15 +7,15 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tu(vfloat16mf4x8_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tu(vfloat16mf2x8_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tu(vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tu(vfloat16m1x8_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tu(vfloat16m1x8_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tu(vd, rs1, rs2, vl); } @@ -111,15 +111,15 @@ vuint64m1x8_t test_vluxseg8ei8_v_u64m1x8_tu(vuint64m1x8_t vd, const uint64_t *rs return __riscv_vluxseg8ei8_tu(vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tum(vm, vd, rs1, rs2, vl); } @@ -215,15 +215,15 @@ vuint64m1x8_t test_vluxseg8ei8_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, con return __riscv_vluxseg8ei8_tum(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -319,15 +319,15 @@ vuint64m1x8_t test_vluxseg8ei8_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, co return __riscv_vluxseg8ei8_tumu(vm, vd, rs1, rs2, vl); } -vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const float16_t *rs1, vuint8mf8_t rs2, size_t vl) { +vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const float16_t *rs1, vuint8mf4_t rs2, size_t vl) { +vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_mu(vm, vd, rs1, rs2, vl); } -vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const float16_t *rs1, vuint8mf2_t rs2, size_t vl) { +vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vle16.c b/auto-generated/policy_funcs/overloaded-api-testing/vle16.c index 71be13599..9dede8fcf 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vle16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vle16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vle16_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vle16_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tu(vd, rs1, vl); } -vfloat16mf2_t test_vle16_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vle16_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tu(vd, rs1, vl); } -vfloat16m1_t test_vle16_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vle16_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tu(vd, rs1, vl); } -vfloat16m2_t test_vle16_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vle16_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tu(vd, rs1, vl); } -vfloat16m4_t test_vle16_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vle16_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tu(vd, rs1, vl); } -vfloat16m8_t test_vle16_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, +vfloat16m8_t test_vle16_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, size_t vl) { return __riscv_vle16_tu(vd, rs1, vl); } @@ -92,32 +92,32 @@ vuint16m8_t test_vle16_v_u16m8_tu(vuint16m8_t vd, const uint16_t *rs1, } vfloat16mf4_t test_vle16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_tum(vm, vd, rs1, vl); } vfloat16mf2_t test_vle16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_tum(vm, vd, rs1, vl); } vfloat16m1_t test_vle16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_tum(vm, vd, rs1, vl); } vfloat16m2_t test_vle16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_tum(vm, vd, rs1, vl); } vfloat16m4_t test_vle16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_tum(vm, vd, rs1, vl); } vfloat16m8_t test_vle16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_tum(vm, vd, rs1, vl); } @@ -182,32 +182,32 @@ vuint16m8_t test_vle16_v_u16m8_tum(vbool2_t vm, vuint16m8_t vd, } vfloat16mf4_t test_vle16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_tumu(vm, vd, rs1, vl); } vfloat16mf2_t test_vle16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_tumu(vm, vd, rs1, vl); } vfloat16m1_t test_vle16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_tumu(vm, vd, rs1, vl); } vfloat16m2_t test_vle16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_tumu(vm, vd, rs1, vl); } vfloat16m4_t test_vle16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_tumu(vm, vd, rs1, vl); } vfloat16m8_t test_vle16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_tumu(vm, vd, rs1, vl); } @@ -272,32 +272,32 @@ vuint16m8_t test_vle16_v_u16m8_tumu(vbool2_t vm, vuint16m8_t vd, } vfloat16mf4_t test_vle16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_mu(vm, vd, rs1, vl); } vfloat16mf2_t test_vle16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_mu(vm, vd, rs1, vl); } vfloat16m1_t test_vle16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_mu(vm, vd, rs1, vl); } vfloat16m2_t test_vle16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_mu(vm, vd, rs1, vl); } vfloat16m4_t test_vle16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_mu(vm, vd, rs1, vl); } vfloat16m8_t test_vle16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vle16_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vle16ff.c b/auto-generated/policy_funcs/overloaded-api-testing/vle16ff.c index 73b1fbda1..e986418eb 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vle16ff.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vle16ff.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vle16ff_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vle16ff_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tu(vd, rs1, new_vl, vl); } -vfloat16mf2_t test_vle16ff_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vle16ff_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m1_t test_vle16ff_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vle16ff_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m2_t test_vle16ff_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vle16ff_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m4_t test_vle16ff_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vle16ff_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tu(vd, rs1, new_vl, vl); } -vfloat16m8_t test_vle16ff_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, +vfloat16m8_t test_vle16ff_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tu(vd, rs1, new_vl, vl); } @@ -96,37 +96,37 @@ vuint16m8_t test_vle16ff_v_u16m8_tu(vuint16m8_t vd, const uint16_t *rs1, } vfloat16mf4_t test_vle16ff_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16mf2_t test_vle16ff_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16m1_t test_vle16ff_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16m2_t test_vle16ff_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16m4_t test_vle16ff_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16m8_t test_vle16ff_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tum(vm, vd, rs1, new_vl, vl); } @@ -204,37 +204,37 @@ vuint16m8_t test_vle16ff_v_u16m8_tum(vbool2_t vm, vuint16m8_t vd, } vfloat16mf4_t test_vle16ff_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16mf2_t test_vle16ff_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m1_t test_vle16ff_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m2_t test_vle16ff_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m4_t test_vle16ff_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m8_t test_vle16ff_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_tumu(vm, vd, rs1, new_vl, vl); } @@ -312,37 +312,37 @@ vuint16m8_t test_vle16ff_v_u16m8_tumu(vbool2_t vm, vuint16m8_t vd, } vfloat16mf4_t test_vle16ff_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16mf2_t test_vle16ff_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16m1_t test_vle16ff_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16m2_t test_vle16ff_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16m4_t test_vle16ff_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16m8_t test_vle16ff_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, size_t *new_vl, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vle16ff_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxei16.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxei16.c index dceda6411..192f0eb3c 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxei16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxei16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei16_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vloxei16_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei16_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vloxei16_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei16_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vloxei16_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei16_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vloxei16_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei16_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vloxei16_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei16_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, +vfloat16m8_t test_vloxei16_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_tu(vd, rs1, rs2, vl); } @@ -291,37 +291,37 @@ vuint64m8_t test_vloxei16_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, } vfloat16mf4_t test_vloxei16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint16mf4_t rs2, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint16mf2_t rs2, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint16m1_t rs2, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint16m2_t rs2, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint16m4_t rs2, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vloxei16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint16m8_t rs2, + const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_tum(vm, vd, rs1, rs2, vl); } @@ -630,37 +630,37 @@ vuint64m8_t test_vloxei16_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vloxei16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, - vuint16mf4_t rs2, size_t vl) { + const _Float16 *rs1, vuint16mf4_t rs2, + size_t vl) { return __riscv_vloxei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, - vuint16mf2_t rs2, size_t vl) { + const _Float16 *rs1, vuint16mf2_t rs2, + size_t vl) { return __riscv_vloxei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint16m1_t rs2, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint16m2_t rs2, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint16m4_t rs2, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vloxei16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint16m8_t rs2, + const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_tumu(vm, vd, rs1, rs2, vl); } @@ -972,37 +972,37 @@ vuint64m8_t test_vloxei16_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vloxei16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint16mf4_t rs2, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxei16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint16mf2_t rs2, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint16m1_t rs2, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint16m2_t rs2, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint16m4_t rs2, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vloxei16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint16m8_t rs2, + const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vloxei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxei32.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxei32.c index d597625d2..9354f6dfc 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxei32.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxei32.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei32_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vloxei32_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei32_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vloxei32_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei32_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vloxei32_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei32_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vloxei32_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei32_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vloxei32_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_tu(vd, rs1, rs2, vl); } @@ -266,31 +266,31 @@ vuint64m8_t test_vloxei32_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, } vfloat16mf4_t test_vloxei32_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint32mf2_t rs2, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei32_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint32m1_t rs2, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei32_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint32m2_t rs2, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei32_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint32m4_t rs2, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei32_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint32m8_t rs2, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_tum(vm, vd, rs1, rs2, vl); } @@ -576,31 +576,31 @@ vuint64m8_t test_vloxei32_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vloxei32_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, - vuint32mf2_t rs2, size_t vl) { + const _Float16 *rs1, vuint32mf2_t rs2, + size_t vl) { return __riscv_vloxei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei32_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint32m1_t rs2, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei32_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint32m2_t rs2, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei32_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint32m4_t rs2, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei32_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint32m8_t rs2, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_tumu(vm, vd, rs1, rs2, vl); } @@ -888,31 +888,31 @@ vuint64m8_t test_vloxei32_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vloxei32_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint32mf2_t rs2, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxei32_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei32_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint32m1_t rs2, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei32_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint32m2_t rs2, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei32_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint32m4_t rs2, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei32_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint32m8_t rs2, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxei64.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxei64.c index b320de6ab..f3f4c3030 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxei64.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei64_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vloxei64_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei64_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vloxei64_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei64_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vloxei64_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei64_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vloxei64_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_tu(vd, rs1, rs2, vl); } @@ -226,25 +226,25 @@ vuint64m8_t test_vloxei64_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, } vfloat16mf4_t test_vloxei64_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint64m1_t rs2, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei64_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint64m2_t rs2, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei64_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint64m4_t rs2, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei64_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint64m8_t rs2, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_tum(vm, vd, rs1, rs2, vl); } @@ -489,25 +489,25 @@ vuint64m8_t test_vloxei64_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vloxei64_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint64m1_t rs2, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei64_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint64m2_t rs2, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei64_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint64m4_t rs2, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei64_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint64m8_t rs2, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_tumu(vm, vd, rs1, rs2, vl); } @@ -753,25 +753,25 @@ vuint64m8_t test_vloxei64_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vloxei64_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint64m1_t rs2, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxei64_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei64_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint64m2_t rs2, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei64_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint64m4_t rs2, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei64_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint64m8_t rs2, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxei8.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxei8.c index d4f0aa869..ed17d17fe 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxei8.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxei8.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vloxei8_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vloxei8_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vloxei8_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vloxei8_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vloxei8_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vloxei8_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vloxei8_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vloxei8_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vloxei8_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vloxei8_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vloxei8_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, +vfloat16m8_t test_vloxei8_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_tu(vd, rs1, rs2, vl); } @@ -301,37 +301,37 @@ vuint64m8_t test_vloxei8_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, } vfloat16mf4_t test_vloxei8_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint8mf8_t rs2, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei8_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint8mf4_t rs2, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei8_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint8mf2_t rs2, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei8_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint8m1_t rs2, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei8_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint8m2_t rs2, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vloxei8_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint8m4_t rs2, + const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_tum(vm, vd, rs1, rs2, vl); } @@ -651,37 +651,37 @@ vuint64m8_t test_vloxei8_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vloxei8_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint8mf8_t rs2, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei8_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint8mf4_t rs2, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei8_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint8mf2_t rs2, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei8_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint8m1_t rs2, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei8_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint8m2_t rs2, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vloxei8_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint8m4_t rs2, + const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_tumu(vm, vd, rs1, rs2, vl); } @@ -1001,37 +1001,37 @@ vuint64m8_t test_vloxei8_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vloxei8_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint8mf8_t rs2, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxei8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vloxei8_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint8mf4_t rs2, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vloxei8_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint8mf2_t rs2, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vloxei8_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint8m1_t rs2, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vloxei8_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint8m2_t rs2, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vloxei8_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint8m4_t rs2, + const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vloxei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg2ei16.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg2ei16.c index 7cbe1d731..7b6c967bd 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg2ei16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg2ei16.c @@ -6,31 +6,31 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tu(vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tu(vd, rs1, rs2, vl); } @@ -277,32 +277,32 @@ vuint64m4x2_t test_vloxseg2ei16_v_u64m4x2_tu(vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tum(vm, vd, rs1, rs2, vl); } @@ -568,32 +568,32 @@ vuint64m4x2_t test_vloxseg2ei16_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -862,32 +862,32 @@ vuint64m4x2_t test_vloxseg2ei16_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg2ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg2ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vloxseg2ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg2ei32.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg2ei32.c index 3404ba008..f7d7ad8e3 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg2ei32.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg2ei32.c @@ -6,31 +6,31 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tu(vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tu(vd, rs1, rs2, vl); } @@ -267,32 +267,32 @@ vuint64m4x2_t test_vloxseg2ei32_v_u64m4x2_tu(vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tum(vm, vd, rs1, rs2, vl); } @@ -546,32 +546,32 @@ vuint64m4x2_t test_vloxseg2ei32_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -828,32 +828,32 @@ vuint64m4x2_t test_vloxseg2ei32_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei32_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei32_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg2ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei32_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg2ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei32_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg2ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei32_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vloxseg2ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg2ei64.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg2ei64.c index 7255e44f5..f54fd52e0 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg2ei64.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg2ei64.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tu(vd, rs1, rs2, vl); } @@ -240,26 +240,26 @@ vuint64m4x2_t test_vloxseg2ei64_v_u64m4x2_tu(vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tum(vm, vd, rs1, rs2, vl); } @@ -489,26 +489,26 @@ vuint64m4x2_t test_vloxseg2ei64_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -741,26 +741,26 @@ vuint64m4x2_t test_vloxseg2ei64_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei64_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg2ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei64_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg2ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei64_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg2ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei64_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg2ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg2ei8.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg2ei8.c index 638b38aa3..645495b80 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg2ei8.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg2ei8.c @@ -6,31 +6,31 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tu(vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tu(vd, rs1, rs2, vl); } @@ -277,32 +277,32 @@ vuint64m4x2_t test_vloxseg2ei8_v_u64m4x2_tu(vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tum(vm, vd, rs1, rs2, vl); } @@ -568,32 +568,32 @@ vuint64m4x2_t test_vloxseg2ei8_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -858,31 +858,31 @@ vuint64m4x2_t test_vloxseg2ei8_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, } vfloat16mf4x2_t test_vloxseg2ei8_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg2ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vloxseg2ei8_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg2ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vloxseg2ei8_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vloxseg2ei8_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg2ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vloxseg2ei8_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vloxseg2ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg3ei16.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg3ei16.c index 8ceeadf91..a6960d3e2 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg3ei16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg3ei16.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x3_t test_vloxseg3ei16_v_u64m2x3_tu(vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x3_t test_vloxseg3ei16_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -669,26 +669,26 @@ vuint64m2x3_t test_vloxseg3ei16_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg3ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg3ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg3ei32.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg3ei32.c index 288026d5e..b217d9007 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg3ei32.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg3ei32.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x3_t test_vloxseg3ei32_v_u64m2x3_tu(vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x3_t test_vloxseg3ei32_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -669,26 +669,26 @@ vuint64m2x3_t test_vloxseg3ei32_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei32_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei32_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg3ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei32_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg3ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei32_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg3ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg3ei64.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg3ei64.c index facb5aabd..b207d90e4 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg3ei64.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg3ei64.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tu(vd, rs1, rs2, vl); } @@ -206,26 +206,26 @@ vuint64m2x3_t test_vloxseg3ei64_v_u64m2x3_tu(vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tum(vm, vd, rs1, rs2, vl); } @@ -419,26 +419,26 @@ vuint64m2x3_t test_vloxseg3ei64_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -635,26 +635,26 @@ vuint64m2x3_t test_vloxseg3ei64_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei64_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg3ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei64_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg3ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei64_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg3ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei64_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg3ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg3ei8.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg3ei8.c index 81bd0184e..7b78abecb 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg3ei8.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg3ei8.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x3_t test_vloxseg3ei8_v_u64m2x3_tu(vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x3_t test_vloxseg3ei8_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -665,25 +665,25 @@ vuint64m2x3_t test_vloxseg3ei8_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, } vfloat16mf4x3_t test_vloxseg3ei8_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg3ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vloxseg3ei8_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg3ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vloxseg3ei8_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg3ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vloxseg3ei8_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg3ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg4ei16.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg4ei16.c index cb0f21806..045ec28c1 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg4ei16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg4ei16.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x4_t test_vloxseg4ei16_v_u64m2x4_tu(vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x4_t test_vloxseg4ei16_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -669,26 +669,26 @@ vuint64m2x4_t test_vloxseg4ei16_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg4ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vloxseg4ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg4ei32.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg4ei32.c index f4db3ba47..1ad9f303f 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg4ei32.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg4ei32.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x4_t test_vloxseg4ei32_v_u64m2x4_tu(vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x4_t test_vloxseg4ei32_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -669,26 +669,26 @@ vuint64m2x4_t test_vloxseg4ei32_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei32_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei32_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg4ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei32_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg4ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei32_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vloxseg4ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg4ei64.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg4ei64.c index d655cc566..ebafe46fa 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg4ei64.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg4ei64.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tu(vd, rs1, rs2, vl); } @@ -206,26 +206,26 @@ vuint64m2x4_t test_vloxseg4ei64_v_u64m2x4_tu(vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tum(vm, vd, rs1, rs2, vl); } @@ -419,26 +419,26 @@ vuint64m2x4_t test_vloxseg4ei64_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -635,26 +635,26 @@ vuint64m2x4_t test_vloxseg4ei64_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei64_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg4ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei64_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg4ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei64_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg4ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei64_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vloxseg4ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg4ei8.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg4ei8.c index 9fdec4663..870d46b16 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg4ei8.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg4ei8.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x4_t test_vloxseg4ei8_v_u64m2x4_tu(vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x4_t test_vloxseg4ei8_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -665,25 +665,25 @@ vuint64m2x4_t test_vloxseg4ei8_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, } vfloat16mf4x4_t test_vloxseg4ei8_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg4ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vloxseg4ei8_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg4ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vloxseg4ei8_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg4ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vloxseg4ei8_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vloxseg4ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg5ei16.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg5ei16.c index 6e50752c6..5bb9bdc57 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg5ei16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg5ei16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x5_t test_vloxseg5ei16_v_u64m1x5_tu(vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x5_t test_vloxseg5ei16_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x5_t test_vloxseg5ei16_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg5ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg5ei32.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg5ei32.c index a58d849d9..b06023fcb 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg5ei32.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg5ei32.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x5_t test_vloxseg5ei32_v_u64m1x5_tu(vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x5_t test_vloxseg5ei32_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x5_t test_vloxseg5ei32_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei32_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei32_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg5ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei32_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg5ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg5ei64.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg5ei64.c index 70fff81e1..ecd25f00a 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg5ei64.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg5ei64.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x5_t test_vloxseg5ei64_v_u64m1x5_tu(vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x5_t test_vloxseg5ei64_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x5_t test_vloxseg5ei64_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei64_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg5ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei64_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg5ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei64_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg5ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg5ei8.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg5ei8.c index 342c1350f..f3821e2ac 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg5ei8.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg5ei8.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x5_t test_vloxseg5ei8_v_u64m1x5_tu(vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x5_t test_vloxseg5ei8_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -472,19 +472,19 @@ vuint64m1x5_t test_vloxseg5ei8_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, } vfloat16mf4x5_t test_vloxseg5ei8_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg5ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vloxseg5ei8_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg5ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vloxseg5ei8_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg5ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg6ei16.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg6ei16.c index c4a5f9a0f..e375b4bdc 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg6ei16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg6ei16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x6_t test_vloxseg6ei16_v_u64m1x6_tu(vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x6_t test_vloxseg6ei16_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x6_t test_vloxseg6ei16_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg6ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg6ei32.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg6ei32.c index 76881010a..a6723060c 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg6ei32.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg6ei32.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x6_t test_vloxseg6ei32_v_u64m1x6_tu(vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x6_t test_vloxseg6ei32_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x6_t test_vloxseg6ei32_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei32_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei32_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg6ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei32_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg6ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg6ei64.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg6ei64.c index 23446ac8b..6fcbc81d5 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg6ei64.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg6ei64.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x6_t test_vloxseg6ei64_v_u64m1x6_tu(vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x6_t test_vloxseg6ei64_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x6_t test_vloxseg6ei64_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei64_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg6ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei64_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg6ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei64_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg6ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg6ei8.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg6ei8.c index aa534ef7d..9dcdeba76 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg6ei8.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg6ei8.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x6_t test_vloxseg6ei8_v_u64m1x6_tu(vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x6_t test_vloxseg6ei8_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -472,19 +472,19 @@ vuint64m1x6_t test_vloxseg6ei8_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, } vfloat16mf4x6_t test_vloxseg6ei8_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg6ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vloxseg6ei8_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg6ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vloxseg6ei8_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg6ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg7ei16.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg7ei16.c index 7f1b5d54a..26e4f333f 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg7ei16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg7ei16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x7_t test_vloxseg7ei16_v_u64m1x7_tu(vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x7_t test_vloxseg7ei16_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x7_t test_vloxseg7ei16_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg7ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg7ei32.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg7ei32.c index c24cf799d..4bd7e435c 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg7ei32.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg7ei32.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x7_t test_vloxseg7ei32_v_u64m1x7_tu(vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x7_t test_vloxseg7ei32_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x7_t test_vloxseg7ei32_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei32_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei32_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg7ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei32_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg7ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg7ei64.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg7ei64.c index 13ac60d39..e1ea1c00b 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg7ei64.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg7ei64.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x7_t test_vloxseg7ei64_v_u64m1x7_tu(vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x7_t test_vloxseg7ei64_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x7_t test_vloxseg7ei64_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei64_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg7ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei64_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg7ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei64_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg7ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg7ei8.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg7ei8.c index 6bf529614..a39fa55e9 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg7ei8.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg7ei8.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x7_t test_vloxseg7ei8_v_u64m1x7_tu(vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x7_t test_vloxseg7ei8_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -472,19 +472,19 @@ vuint64m1x7_t test_vloxseg7ei8_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, } vfloat16mf4x7_t test_vloxseg7ei8_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg7ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vloxseg7ei8_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg7ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vloxseg7ei8_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg7ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg8ei16.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg8ei16.c index c2647324c..7a307e43f 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg8ei16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg8ei16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x8_t test_vloxseg8ei16_v_u64m1x8_tu(vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x8_t test_vloxseg8ei16_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x8_t test_vloxseg8ei16_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vloxseg8ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg8ei32.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg8ei32.c index 98a3905ca..3115b2ecb 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg8ei32.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg8ei32.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x8_t test_vloxseg8ei32_v_u64m1x8_tu(vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x8_t test_vloxseg8ei32_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x8_t test_vloxseg8ei32_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei32_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei32_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vloxseg8ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei32_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vloxseg8ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg8ei64.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg8ei64.c index 95cced6ed..a61483616 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg8ei64.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg8ei64.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x8_t test_vloxseg8ei64_v_u64m1x8_tu(vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x8_t test_vloxseg8ei64_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x8_t test_vloxseg8ei64_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei64_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vloxseg8ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei64_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vloxseg8ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei64_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vloxseg8ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg8ei8.c b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg8ei8.c index 42e0e9ce5..d79b67cc9 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vloxseg8ei8.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vloxseg8ei8.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x8_t test_vloxseg8ei8_v_u64m1x8_tu(vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x8_t test_vloxseg8ei8_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -472,19 +472,19 @@ vuint64m1x8_t test_vloxseg8ei8_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, } vfloat16mf4x8_t test_vloxseg8ei8_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vloxseg8ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vloxseg8ei8_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vloxseg8ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vloxseg8ei8_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vloxseg8ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlse16.c b/auto-generated/policy_funcs/overloaded-api-testing/vlse16.c index 6a2675343..525b86866 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlse16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlse16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vlse16_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vlse16_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vlse16_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vlse16_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vlse16_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vlse16_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vlse16_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vlse16_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vlse16_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vlse16_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vlse16_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, +vfloat16m8_t test_vlse16_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tu(vd, rs1, rs2, vl); } @@ -96,37 +96,37 @@ vuint16m8_t test_vlse16_v_u16m8_tu(vuint16m8_t vd, const uint16_t *rs1, } vfloat16mf4_t test_vlse16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vlse16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vlse16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vlse16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tum(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vlse16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tum(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vlse16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tum(vm, vd, rs1, rs2, vl); } @@ -204,37 +204,37 @@ vuint16m8_t test_vlse16_v_u16m8_tum(vbool2_t vm, vuint16m8_t vd, } vfloat16mf4_t test_vlse16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vlse16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vlse16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vlse16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vlse16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vlse16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_tumu(vm, vd, rs1, rs2, vl); } @@ -312,37 +312,37 @@ vuint16m8_t test_vlse16_v_u16m8_tumu(vbool2_t vm, vuint16m8_t vd, } vfloat16mf4_t test_vlse16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vlse16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vlse16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vlse16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_mu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vlse16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_mu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vlse16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlse16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlseg2e16.c b/auto-generated/policy_funcs/overloaded-api-testing/vlseg2e16.c index ee085dc5a..c7c9262bb 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlseg2e16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlseg2e16.c @@ -6,27 +6,27 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tu(vd, rs1, vl); } vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tu(vd, rs1, vl); } vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tu(vd, rs1, vl); } vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tu(vd, rs1, vl); } vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tu(vd, rs1, vl); } @@ -81,27 +81,27 @@ vuint16m4x2_t test_vlseg2e16_v_u16m4x2_tu(vuint16m4x2_t vd, const uint16_t *rs1, } vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tum(vm, vd, rs1, vl); } vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tum(vm, vd, rs1, vl); } vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tum(vm, vd, rs1, vl); } vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tum(vm, vd, rs1, vl); } vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tum(vm, vd, rs1, vl); } @@ -156,29 +156,27 @@ vuint16m4x2_t test_vlseg2e16_v_u16m4x2_tum(vbool4_t vm, vuint16m4x2_t vd, } vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tumu(vm, vd, rs1, vl); } vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tumu(vm, vd, rs1, vl); } vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tumu(vm, vd, rs1, vl); } vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tumu(vm, vd, rs1, vl); } vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_tumu(vm, vd, rs1, vl); } @@ -233,27 +231,27 @@ vuint16m4x2_t test_vlseg2e16_v_u16m4x2_tumu(vbool4_t vm, vuint16m4x2_t vd, } vfloat16mf4x2_t test_vlseg2e16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_mu(vm, vd, rs1, vl); } vfloat16mf2x2_t test_vlseg2e16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_mu(vm, vd, rs1, vl); } vfloat16m1x2_t test_vlseg2e16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_mu(vm, vd, rs1, vl); } vfloat16m2x2_t test_vlseg2e16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_mu(vm, vd, rs1, vl); } vfloat16m4x2_t test_vlseg2e16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg2e16_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlseg2e16ff.c b/auto-generated/policy_funcs/overloaded-api-testing/vlseg2e16ff.c index b6b79e71e..d9bed7791 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlseg2e16ff.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlseg2e16ff.c @@ -6,31 +6,31 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tu(vd, rs1, new_vl, vl); } vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tu(vd, rs1, new_vl, vl); } vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tu(vd, rs1, new_vl, vl); } vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tu(vd, rs1, new_vl, vl); } vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tu(vd, rs1, new_vl, vl); } @@ -94,32 +94,32 @@ vuint16m4x2_t test_vlseg2e16ff_v_u16m4x2_tu(vuint16m4x2_t vd, vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tum(vm, vd, rs1, new_vl, vl); } @@ -186,32 +186,32 @@ vuint16m4x2_t test_vlseg2e16ff_v_u16m4x2_tum(vbool4_t vm, vuint16m4x2_t vd, vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_tumu(vm, vd, rs1, new_vl, vl); } @@ -277,31 +277,31 @@ vuint16m4x2_t test_vlseg2e16ff_v_u16m4x2_tumu(vbool4_t vm, vuint16m4x2_t vd, } vfloat16mf4x2_t test_vlseg2e16ff_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x2_t test_vlseg2e16ff_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16m1x2_t test_vlseg2e16ff_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16m2x2_t test_vlseg2e16ff_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16m4x2_t test_vlseg2e16ff_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg2e16ff_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlseg3e16.c b/auto-generated/policy_funcs/overloaded-api-testing/vlseg3e16.c index 7f5bc3110..24745b6be 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlseg3e16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlseg3e16.c @@ -6,22 +6,22 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tu(vd, rs1, vl); } vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tu(vd, rs1, vl); } vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tu(vd, rs1, vl); } vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tu(vd, rs1, vl); } @@ -66,22 +66,22 @@ vuint16m2x3_t test_vlseg3e16_v_u16m2x3_tu(vuint16m2x3_t vd, const uint16_t *rs1, } vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tum(vm, vd, rs1, vl); } vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tum(vm, vd, rs1, vl); } vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tum(vm, vd, rs1, vl); } vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tum(vm, vd, rs1, vl); } @@ -126,24 +126,22 @@ vuint16m2x3_t test_vlseg3e16_v_u16m2x3_tum(vbool8_t vm, vuint16m2x3_t vd, } vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tumu(vm, vd, rs1, vl); } vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tumu(vm, vd, rs1, vl); } vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tumu(vm, vd, rs1, vl); } vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_tumu(vm, vd, rs1, vl); } @@ -188,22 +186,22 @@ vuint16m2x3_t test_vlseg3e16_v_u16m2x3_tumu(vbool8_t vm, vuint16m2x3_t vd, } vfloat16mf4x3_t test_vlseg3e16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_mu(vm, vd, rs1, vl); } vfloat16mf2x3_t test_vlseg3e16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_mu(vm, vd, rs1, vl); } vfloat16m1x3_t test_vlseg3e16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_mu(vm, vd, rs1, vl); } vfloat16m2x3_t test_vlseg3e16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg3e16_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlseg3e16ff.c b/auto-generated/policy_funcs/overloaded-api-testing/vlseg3e16ff.c index ce9024c9b..41963b05d 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlseg3e16ff.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlseg3e16ff.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tu(vd, rs1, new_vl, vl); } vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tu(vd, rs1, new_vl, vl); } vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tu(vd, rs1, new_vl, vl); } vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tu(vd, rs1, new_vl, vl); } @@ -77,26 +77,26 @@ vuint16m2x3_t test_vlseg3e16ff_v_u16m2x3_tu(vuint16m2x3_t vd, vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tum(vm, vd, rs1, new_vl, vl); } @@ -151,26 +151,26 @@ vuint16m2x3_t test_vlseg3e16ff_v_u16m2x3_tum(vbool8_t vm, vuint16m2x3_t vd, vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_tumu(vm, vd, rs1, new_vl, vl); } @@ -224,25 +224,25 @@ vuint16m2x3_t test_vlseg3e16ff_v_u16m2x3_tumu(vbool8_t vm, vuint16m2x3_t vd, } vfloat16mf4x3_t test_vlseg3e16ff_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x3_t test_vlseg3e16ff_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16m1x3_t test_vlseg3e16ff_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16m2x3_t test_vlseg3e16ff_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg3e16ff_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlseg4e16.c b/auto-generated/policy_funcs/overloaded-api-testing/vlseg4e16.c index cfbb7d5a7..e13ace296 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlseg4e16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlseg4e16.c @@ -6,22 +6,22 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tu(vd, rs1, vl); } vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tu(vd, rs1, vl); } vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tu(vd, rs1, vl); } vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tu(vd, rs1, vl); } @@ -66,22 +66,22 @@ vuint16m2x4_t test_vlseg4e16_v_u16m2x4_tu(vuint16m2x4_t vd, const uint16_t *rs1, } vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tum(vm, vd, rs1, vl); } vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tum(vm, vd, rs1, vl); } vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tum(vm, vd, rs1, vl); } vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tum(vm, vd, rs1, vl); } @@ -126,24 +126,22 @@ vuint16m2x4_t test_vlseg4e16_v_u16m2x4_tum(vbool8_t vm, vuint16m2x4_t vd, } vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tumu(vm, vd, rs1, vl); } vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tumu(vm, vd, rs1, vl); } vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tumu(vm, vd, rs1, vl); } vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_tumu(vm, vd, rs1, vl); } @@ -188,22 +186,22 @@ vuint16m2x4_t test_vlseg4e16_v_u16m2x4_tumu(vbool8_t vm, vuint16m2x4_t vd, } vfloat16mf4x4_t test_vlseg4e16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_mu(vm, vd, rs1, vl); } vfloat16mf2x4_t test_vlseg4e16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_mu(vm, vd, rs1, vl); } vfloat16m1x4_t test_vlseg4e16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_mu(vm, vd, rs1, vl); } vfloat16m2x4_t test_vlseg4e16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg4e16_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlseg4e16ff.c b/auto-generated/policy_funcs/overloaded-api-testing/vlseg4e16ff.c index 20e1fd243..1498b0b30 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlseg4e16ff.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlseg4e16ff.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tu(vd, rs1, new_vl, vl); } vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tu(vd, rs1, new_vl, vl); } vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tu(vd, rs1, new_vl, vl); } vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tu(vd, rs1, new_vl, vl); } @@ -77,26 +77,26 @@ vuint16m2x4_t test_vlseg4e16ff_v_u16m2x4_tu(vuint16m2x4_t vd, vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tum(vm, vd, rs1, new_vl, vl); } @@ -151,26 +151,26 @@ vuint16m2x4_t test_vlseg4e16ff_v_u16m2x4_tum(vbool8_t vm, vuint16m2x4_t vd, vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_tumu(vm, vd, rs1, new_vl, vl); } @@ -224,25 +224,25 @@ vuint16m2x4_t test_vlseg4e16ff_v_u16m2x4_tumu(vbool8_t vm, vuint16m2x4_t vd, } vfloat16mf4x4_t test_vlseg4e16ff_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x4_t test_vlseg4e16ff_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16m1x4_t test_vlseg4e16ff_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16m2x4_t test_vlseg4e16ff_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg4e16ff_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlseg5e16.c b/auto-generated/policy_funcs/overloaded-api-testing/vlseg5e16.c index 4c3d1541d..9721e7ecd 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlseg5e16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlseg5e16.c @@ -6,17 +6,17 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tu(vd, rs1, vl); } vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tu(vd, rs1, vl); } vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tu(vd, rs1, vl); } @@ -51,17 +51,17 @@ vuint16m1x5_t test_vlseg5e16_v_u16m1x5_tu(vuint16m1x5_t vd, const uint16_t *rs1, } vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tum(vm, vd, rs1, vl); } vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tum(vm, vd, rs1, vl); } vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tum(vm, vd, rs1, vl); } @@ -96,19 +96,17 @@ vuint16m1x5_t test_vlseg5e16_v_u16m1x5_tum(vbool16_t vm, vuint16m1x5_t vd, } vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tumu(vm, vd, rs1, vl); } vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tumu(vm, vd, rs1, vl); } vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_tumu(vm, vd, rs1, vl); } @@ -143,17 +141,17 @@ vuint16m1x5_t test_vlseg5e16_v_u16m1x5_tumu(vbool16_t vm, vuint16m1x5_t vd, } vfloat16mf4x5_t test_vlseg5e16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_mu(vm, vd, rs1, vl); } vfloat16mf2x5_t test_vlseg5e16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_mu(vm, vd, rs1, vl); } vfloat16m1x5_t test_vlseg5e16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg5e16_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlseg5e16ff.c b/auto-generated/policy_funcs/overloaded-api-testing/vlseg5e16ff.c index b3a99c1e9..75b492580 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlseg5e16ff.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlseg5e16ff.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tu(vd, rs1, new_vl, vl); } vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tu(vd, rs1, new_vl, vl); } vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tu(vd, rs1, new_vl, vl); } @@ -60,20 +60,20 @@ vuint16m1x5_t test_vlseg5e16ff_v_u16m1x5_tu(vuint16m1x5_t vd, vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tum(vm, vd, rs1, new_vl, vl); } @@ -116,20 +116,20 @@ vuint16m1x5_t test_vlseg5e16ff_v_u16m1x5_tum(vbool16_t vm, vuint16m1x5_t vd, vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_tumu(vm, vd, rs1, new_vl, vl); } @@ -171,19 +171,19 @@ vuint16m1x5_t test_vlseg5e16ff_v_u16m1x5_tumu(vbool16_t vm, vuint16m1x5_t vd, } vfloat16mf4x5_t test_vlseg5e16ff_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x5_t test_vlseg5e16ff_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16m1x5_t test_vlseg5e16ff_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg5e16ff_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlseg6e16.c b/auto-generated/policy_funcs/overloaded-api-testing/vlseg6e16.c index 8954499b4..6bb1861b6 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlseg6e16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlseg6e16.c @@ -6,17 +6,17 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tu(vd, rs1, vl); } vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tu(vd, rs1, vl); } vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tu(vd, rs1, vl); } @@ -51,17 +51,17 @@ vuint16m1x6_t test_vlseg6e16_v_u16m1x6_tu(vuint16m1x6_t vd, const uint16_t *rs1, } vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tum(vm, vd, rs1, vl); } vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tum(vm, vd, rs1, vl); } vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tum(vm, vd, rs1, vl); } @@ -96,19 +96,17 @@ vuint16m1x6_t test_vlseg6e16_v_u16m1x6_tum(vbool16_t vm, vuint16m1x6_t vd, } vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tumu(vm, vd, rs1, vl); } vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tumu(vm, vd, rs1, vl); } vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_tumu(vm, vd, rs1, vl); } @@ -143,17 +141,17 @@ vuint16m1x6_t test_vlseg6e16_v_u16m1x6_tumu(vbool16_t vm, vuint16m1x6_t vd, } vfloat16mf4x6_t test_vlseg6e16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_mu(vm, vd, rs1, vl); } vfloat16mf2x6_t test_vlseg6e16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_mu(vm, vd, rs1, vl); } vfloat16m1x6_t test_vlseg6e16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg6e16_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlseg6e16ff.c b/auto-generated/policy_funcs/overloaded-api-testing/vlseg6e16ff.c index 6dacef812..9b66ff479 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlseg6e16ff.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlseg6e16ff.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tu(vd, rs1, new_vl, vl); } vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tu(vd, rs1, new_vl, vl); } vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tu(vd, rs1, new_vl, vl); } @@ -60,20 +60,20 @@ vuint16m1x6_t test_vlseg6e16ff_v_u16m1x6_tu(vuint16m1x6_t vd, vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tum(vm, vd, rs1, new_vl, vl); } @@ -116,20 +116,20 @@ vuint16m1x6_t test_vlseg6e16ff_v_u16m1x6_tum(vbool16_t vm, vuint16m1x6_t vd, vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_tumu(vm, vd, rs1, new_vl, vl); } @@ -171,19 +171,19 @@ vuint16m1x6_t test_vlseg6e16ff_v_u16m1x6_tumu(vbool16_t vm, vuint16m1x6_t vd, } vfloat16mf4x6_t test_vlseg6e16ff_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x6_t test_vlseg6e16ff_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16m1x6_t test_vlseg6e16ff_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg6e16ff_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlseg7e16.c b/auto-generated/policy_funcs/overloaded-api-testing/vlseg7e16.c index 537914d46..ef06e935e 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlseg7e16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlseg7e16.c @@ -6,17 +6,17 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tu(vd, rs1, vl); } vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tu(vd, rs1, vl); } vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tu(vd, rs1, vl); } @@ -51,17 +51,17 @@ vuint16m1x7_t test_vlseg7e16_v_u16m1x7_tu(vuint16m1x7_t vd, const uint16_t *rs1, } vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tum(vm, vd, rs1, vl); } vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tum(vm, vd, rs1, vl); } vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tum(vm, vd, rs1, vl); } @@ -96,19 +96,17 @@ vuint16m1x7_t test_vlseg7e16_v_u16m1x7_tum(vbool16_t vm, vuint16m1x7_t vd, } vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tumu(vm, vd, rs1, vl); } vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tumu(vm, vd, rs1, vl); } vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_tumu(vm, vd, rs1, vl); } @@ -143,17 +141,17 @@ vuint16m1x7_t test_vlseg7e16_v_u16m1x7_tumu(vbool16_t vm, vuint16m1x7_t vd, } vfloat16mf4x7_t test_vlseg7e16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_mu(vm, vd, rs1, vl); } vfloat16mf2x7_t test_vlseg7e16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_mu(vm, vd, rs1, vl); } vfloat16m1x7_t test_vlseg7e16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg7e16_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlseg7e16ff.c b/auto-generated/policy_funcs/overloaded-api-testing/vlseg7e16ff.c index 17a4572e0..9cf9be07a 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlseg7e16ff.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlseg7e16ff.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tu(vd, rs1, new_vl, vl); } vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tu(vd, rs1, new_vl, vl); } vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tu(vd, rs1, new_vl, vl); } @@ -60,20 +60,20 @@ vuint16m1x7_t test_vlseg7e16ff_v_u16m1x7_tu(vuint16m1x7_t vd, vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tum(vm, vd, rs1, new_vl, vl); } @@ -116,20 +116,20 @@ vuint16m1x7_t test_vlseg7e16ff_v_u16m1x7_tum(vbool16_t vm, vuint16m1x7_t vd, vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_tumu(vm, vd, rs1, new_vl, vl); } @@ -171,19 +171,19 @@ vuint16m1x7_t test_vlseg7e16ff_v_u16m1x7_tumu(vbool16_t vm, vuint16m1x7_t vd, } vfloat16mf4x7_t test_vlseg7e16ff_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x7_t test_vlseg7e16ff_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16m1x7_t test_vlseg7e16ff_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg7e16ff_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlseg8e16.c b/auto-generated/policy_funcs/overloaded-api-testing/vlseg8e16.c index 86a2b4a43..4d330208b 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlseg8e16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlseg8e16.c @@ -6,17 +6,17 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tu(vd, rs1, vl); } vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tu(vd, rs1, vl); } vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tu(vd, rs1, vl); } @@ -51,17 +51,17 @@ vuint16m1x8_t test_vlseg8e16_v_u16m1x8_tu(vuint16m1x8_t vd, const uint16_t *rs1, } vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tum(vm, vd, rs1, vl); } vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tum(vm, vd, rs1, vl); } vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tum(vm, vd, rs1, vl); } @@ -96,19 +96,17 @@ vuint16m1x8_t test_vlseg8e16_v_u16m1x8_tum(vbool16_t vm, vuint16m1x8_t vd, } vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tumu(vm, vd, rs1, vl); } vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, - size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tumu(vm, vd, rs1, vl); } vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_tumu(vm, vd, rs1, vl); } @@ -143,17 +141,17 @@ vuint16m1x8_t test_vlseg8e16_v_u16m1x8_tumu(vbool16_t vm, vuint16m1x8_t vd, } vfloat16mf4x8_t test_vlseg8e16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_mu(vm, vd, rs1, vl); } vfloat16mf2x8_t test_vlseg8e16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_mu(vm, vd, rs1, vl); } vfloat16m1x8_t test_vlseg8e16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, size_t vl) { + const _Float16 *rs1, size_t vl) { return __riscv_vlseg8e16_mu(vm, vd, rs1, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlseg8e16ff.c b/auto-generated/policy_funcs/overloaded-api-testing/vlseg8e16ff.c index 55b697d9a..fa059222f 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlseg8e16ff.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlseg8e16ff.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tu(vd, rs1, new_vl, vl); } vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tu(vd, rs1, new_vl, vl); } vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tu(vd, rs1, new_vl, vl); } @@ -60,20 +60,20 @@ vuint16m1x8_t test_vlseg8e16ff_v_u16m1x8_tu(vuint16m1x8_t vd, vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tum(vm, vd, rs1, new_vl, vl); } vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tum(vm, vd, rs1, new_vl, vl); } @@ -116,20 +116,20 @@ vuint16m1x8_t test_vlseg8e16ff_v_u16m1x8_tum(vbool16_t vm, vuint16m1x8_t vd, vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tumu(vm, vd, rs1, new_vl, vl); } vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_tumu(vm, vd, rs1, new_vl, vl); } @@ -171,19 +171,19 @@ vuint16m1x8_t test_vlseg8e16ff_v_u16m1x8_tumu(vbool16_t vm, vuint16m1x8_t vd, } vfloat16mf4x8_t test_vlseg8e16ff_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16mf2x8_t test_vlseg8e16ff_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_mu(vm, vd, rs1, new_vl, vl); } vfloat16m1x8_t test_vlseg8e16ff_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, size_t *new_vl, size_t vl) { return __riscv_vlseg8e16ff_mu(vm, vd, rs1, new_vl, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlsseg2e16.c b/auto-generated/policy_funcs/overloaded-api-testing/vlsseg2e16.c index 2876fa4ed..8b1537158 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlsseg2e16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlsseg2e16.c @@ -6,31 +6,31 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tu(vd, rs1, rs2, vl); } vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tu(vd, rs1, rs2, vl); } @@ -93,32 +93,32 @@ vuint16m4x2_t test_vlsseg2e16_v_u16m4x2_tu(vuint16m4x2_t vd, } vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg2e16_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg2e16_tum(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg2e16_tum(vm, vd, rs1, rs2, vl); } @@ -184,32 +184,32 @@ vuint16m4x2_t test_vlsseg2e16_v_u16m4x2_tum(vbool4_t vm, vuint16m4x2_t vd, vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_tumu(vm, vd, rs1, rs2, vl); } @@ -275,31 +275,31 @@ vuint16m4x2_t test_vlsseg2e16_v_u16m4x2_tumu(vbool4_t vm, vuint16m4x2_t vd, } vfloat16mf4x2_t test_vlsseg2e16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vlsseg2e16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vlsseg2e16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vlsseg2e16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_mu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vlsseg2e16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg2e16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlsseg3e16.c b/auto-generated/policy_funcs/overloaded-api-testing/vlsseg3e16.c index 390ee8782..3b04e2d45 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlsseg3e16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlsseg3e16.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tu(vd, rs1, rs2, vl); } @@ -76,26 +76,26 @@ vuint16m2x3_t test_vlsseg3e16_v_u16m2x3_tu(vuint16m2x3_t vd, } vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg3e16_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg3e16_tum(vm, vd, rs1, rs2, vl); } @@ -149,26 +149,26 @@ vuint16m2x3_t test_vlsseg3e16_v_u16m2x3_tum(vbool8_t vm, vuint16m2x3_t vd, vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_tumu(vm, vd, rs1, rs2, vl); } @@ -222,25 +222,25 @@ vuint16m2x3_t test_vlsseg3e16_v_u16m2x3_tumu(vbool8_t vm, vuint16m2x3_t vd, } vfloat16mf4x3_t test_vlsseg3e16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vlsseg3e16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vlsseg3e16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vlsseg3e16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg3e16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlsseg4e16.c b/auto-generated/policy_funcs/overloaded-api-testing/vlsseg4e16.c index f4ac5272e..3bff3643b 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlsseg4e16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlsseg4e16.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tu(vd, rs1, rs2, vl); } @@ -76,26 +76,26 @@ vuint16m2x4_t test_vlsseg4e16_v_u16m2x4_tu(vuint16m2x4_t vd, } vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg4e16_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg4e16_tum(vm, vd, rs1, rs2, vl); } @@ -149,26 +149,26 @@ vuint16m2x4_t test_vlsseg4e16_v_u16m2x4_tum(vbool8_t vm, vuint16m2x4_t vd, vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_tumu(vm, vd, rs1, rs2, vl); } @@ -222,25 +222,25 @@ vuint16m2x4_t test_vlsseg4e16_v_u16m2x4_tumu(vbool8_t vm, vuint16m2x4_t vd, } vfloat16mf4x4_t test_vlsseg4e16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vlsseg4e16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vlsseg4e16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vlsseg4e16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg4e16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlsseg5e16.c b/auto-generated/policy_funcs/overloaded-api-testing/vlsseg5e16.c index 014809442..96cfc5dc7 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlsseg5e16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlsseg5e16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tu(vd, rs1, rs2, vl); } @@ -59,20 +59,20 @@ vuint16m1x5_t test_vlsseg5e16_v_u16m1x5_tu(vuint16m1x5_t vd, } vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg5e16_tum(vm, vd, rs1, rs2, vl); } @@ -114,20 +114,20 @@ vuint16m1x5_t test_vlsseg5e16_v_u16m1x5_tum(vbool16_t vm, vuint16m1x5_t vd, vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_tumu(vm, vd, rs1, rs2, vl); } @@ -169,19 +169,19 @@ vuint16m1x5_t test_vlsseg5e16_v_u16m1x5_tumu(vbool16_t vm, vuint16m1x5_t vd, } vfloat16mf4x5_t test_vlsseg5e16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vlsseg5e16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vlsseg5e16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg5e16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlsseg6e16.c b/auto-generated/policy_funcs/overloaded-api-testing/vlsseg6e16.c index 00e939bf7..07a0e881f 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlsseg6e16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlsseg6e16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tu(vd, rs1, rs2, vl); } @@ -59,20 +59,20 @@ vuint16m1x6_t test_vlsseg6e16_v_u16m1x6_tu(vuint16m1x6_t vd, } vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg6e16_tum(vm, vd, rs1, rs2, vl); } @@ -114,20 +114,20 @@ vuint16m1x6_t test_vlsseg6e16_v_u16m1x6_tum(vbool16_t vm, vuint16m1x6_t vd, vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_tumu(vm, vd, rs1, rs2, vl); } @@ -169,19 +169,19 @@ vuint16m1x6_t test_vlsseg6e16_v_u16m1x6_tumu(vbool16_t vm, vuint16m1x6_t vd, } vfloat16mf4x6_t test_vlsseg6e16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vlsseg6e16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vlsseg6e16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg6e16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlsseg7e16.c b/auto-generated/policy_funcs/overloaded-api-testing/vlsseg7e16.c index a670b3e4d..d0b0ee261 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlsseg7e16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlsseg7e16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tu(vd, rs1, rs2, vl); } @@ -59,20 +59,20 @@ vuint16m1x7_t test_vlsseg7e16_v_u16m1x7_tu(vuint16m1x7_t vd, } vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg7e16_tum(vm, vd, rs1, rs2, vl); } @@ -114,20 +114,20 @@ vuint16m1x7_t test_vlsseg7e16_v_u16m1x7_tum(vbool16_t vm, vuint16m1x7_t vd, vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_tumu(vm, vd, rs1, rs2, vl); } @@ -169,19 +169,19 @@ vuint16m1x7_t test_vlsseg7e16_v_u16m1x7_tumu(vbool16_t vm, vuint16m1x7_t vd, } vfloat16mf4x7_t test_vlsseg7e16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vlsseg7e16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vlsseg7e16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg7e16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vlsseg8e16.c b/auto-generated/policy_funcs/overloaded-api-testing/vlsseg8e16.c index 7151ac6ed..d7d82bcfe 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vlsseg8e16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vlsseg8e16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tu(vd, rs1, rs2, vl); } @@ -59,20 +59,20 @@ vuint16m1x8_t test_vlsseg8e16_v_u16m1x8_tu(vuint16m1x8_t vd, } vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, - ptrdiff_t rs2, size_t vl) { + const _Float16 *rs1, ptrdiff_t rs2, + size_t vl) { return __riscv_vlsseg8e16_tum(vm, vd, rs1, rs2, vl); } @@ -114,20 +114,20 @@ vuint16m1x8_t test_vlsseg8e16_v_u16m1x8_tum(vbool16_t vm, vuint16m1x8_t vd, vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_tumu(vm, vd, rs1, rs2, vl); } @@ -169,19 +169,19 @@ vuint16m1x8_t test_vlsseg8e16_v_u16m1x8_tumu(vbool16_t vm, vuint16m1x8_t vd, } vfloat16mf4x8_t test_vlsseg8e16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vlsseg8e16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vlsseg8e16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, ptrdiff_t rs2, + const _Float16 *rs1, ptrdiff_t rs2, size_t vl) { return __riscv_vlsseg8e16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxei16.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxei16.c index 38861cee4..b4bdc50c0 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxei16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxei16.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei16_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vluxei16_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei16_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vluxei16_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei16_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vluxei16_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei16_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vluxei16_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei16_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vluxei16_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei16_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, +vfloat16m8_t test_vluxei16_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_tu(vd, rs1, rs2, vl); } @@ -291,37 +291,37 @@ vuint64m8_t test_vluxei16_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, } vfloat16mf4_t test_vluxei16_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint16mf4_t rs2, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei16_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint16mf2_t rs2, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei16_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint16m1_t rs2, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei16_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint16m2_t rs2, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei16_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint16m4_t rs2, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vluxei16_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint16m8_t rs2, + const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_tum(vm, vd, rs1, rs2, vl); } @@ -630,37 +630,37 @@ vuint64m8_t test_vluxei16_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vluxei16_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, - vuint16mf4_t rs2, size_t vl) { + const _Float16 *rs1, vuint16mf4_t rs2, + size_t vl) { return __riscv_vluxei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei16_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, - vuint16mf2_t rs2, size_t vl) { + const _Float16 *rs1, vuint16mf2_t rs2, + size_t vl) { return __riscv_vluxei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei16_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint16m1_t rs2, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei16_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint16m2_t rs2, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei16_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint16m4_t rs2, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vluxei16_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint16m8_t rs2, + const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_tumu(vm, vd, rs1, rs2, vl); } @@ -972,37 +972,37 @@ vuint64m8_t test_vluxei16_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vluxei16_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint16mf4_t rs2, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxei16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei16_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint16mf2_t rs2, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei16_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint16m1_t rs2, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei16_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint16m2_t rs2, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei16_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint16m4_t rs2, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vluxei16_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint16m8_t rs2, + const _Float16 *rs1, vuint16m8_t rs2, size_t vl) { return __riscv_vluxei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxei32.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxei32.c index 3beaf4857..771d8a1d1 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxei32.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxei32.c @@ -5,27 +5,27 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei32_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vluxei32_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei32_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vluxei32_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei32_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vluxei32_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei32_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vluxei32_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei32_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vluxei32_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_tu(vd, rs1, rs2, vl); } @@ -266,31 +266,31 @@ vuint64m8_t test_vluxei32_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, } vfloat16mf4_t test_vluxei32_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint32mf2_t rs2, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei32_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint32m1_t rs2, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei32_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint32m2_t rs2, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei32_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint32m4_t rs2, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei32_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint32m8_t rs2, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_tum(vm, vd, rs1, rs2, vl); } @@ -576,31 +576,31 @@ vuint64m8_t test_vluxei32_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vluxei32_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, - vuint32mf2_t rs2, size_t vl) { + const _Float16 *rs1, vuint32mf2_t rs2, + size_t vl) { return __riscv_vluxei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei32_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint32m1_t rs2, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei32_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint32m2_t rs2, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei32_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint32m4_t rs2, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei32_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint32m8_t rs2, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_tumu(vm, vd, rs1, rs2, vl); } @@ -888,31 +888,31 @@ vuint64m8_t test_vluxei32_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vluxei32_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint32mf2_t rs2, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxei32_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei32_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint32m1_t rs2, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei32_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint32m2_t rs2, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei32_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint32m4_t rs2, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei32_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint32m8_t rs2, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxei64.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxei64.c index ae6ddb744..3a3c8eb7d 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxei64.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxei64.c @@ -5,22 +5,22 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei64_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vluxei64_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei64_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vluxei64_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei64_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vluxei64_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei64_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vluxei64_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_tu(vd, rs1, rs2, vl); } @@ -226,25 +226,25 @@ vuint64m8_t test_vluxei64_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, } vfloat16mf4_t test_vluxei64_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint64m1_t rs2, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei64_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint64m2_t rs2, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei64_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint64m4_t rs2, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei64_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint64m8_t rs2, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_tum(vm, vd, rs1, rs2, vl); } @@ -489,25 +489,25 @@ vuint64m8_t test_vluxei64_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vluxei64_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint64m1_t rs2, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei64_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint64m2_t rs2, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei64_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint64m4_t rs2, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei64_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint64m8_t rs2, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_tumu(vm, vd, rs1, rs2, vl); } @@ -753,25 +753,25 @@ vuint64m8_t test_vluxei64_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vluxei64_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint64m1_t rs2, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxei64_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei64_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint64m2_t rs2, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei64_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint64m4_t rs2, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei64_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint64m8_t rs2, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxei8.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxei8.c index e3b14519d..62f62d023 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxei8.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxei8.c @@ -5,32 +5,32 @@ typedef _Float16 float16_t; typedef float float32_t; typedef double float64_t; -vfloat16mf4_t test_vluxei8_v_f16mf4_tu(vfloat16mf4_t vd, const float16_t *rs1, +vfloat16mf4_t test_vluxei8_v_f16mf4_tu(vfloat16mf4_t vd, const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_tu(vd, rs1, rs2, vl); } -vfloat16mf2_t test_vluxei8_v_f16mf2_tu(vfloat16mf2_t vd, const float16_t *rs1, +vfloat16mf2_t test_vluxei8_v_f16mf2_tu(vfloat16mf2_t vd, const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_tu(vd, rs1, rs2, vl); } -vfloat16m1_t test_vluxei8_v_f16m1_tu(vfloat16m1_t vd, const float16_t *rs1, +vfloat16m1_t test_vluxei8_v_f16m1_tu(vfloat16m1_t vd, const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_tu(vd, rs1, rs2, vl); } -vfloat16m2_t test_vluxei8_v_f16m2_tu(vfloat16m2_t vd, const float16_t *rs1, +vfloat16m2_t test_vluxei8_v_f16m2_tu(vfloat16m2_t vd, const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_tu(vd, rs1, rs2, vl); } -vfloat16m4_t test_vluxei8_v_f16m4_tu(vfloat16m4_t vd, const float16_t *rs1, +vfloat16m4_t test_vluxei8_v_f16m4_tu(vfloat16m4_t vd, const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_tu(vd, rs1, rs2, vl); } -vfloat16m8_t test_vluxei8_v_f16m8_tu(vfloat16m8_t vd, const float16_t *rs1, +vfloat16m8_t test_vluxei8_v_f16m8_tu(vfloat16m8_t vd, const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_tu(vd, rs1, rs2, vl); } @@ -301,37 +301,37 @@ vuint64m8_t test_vluxei8_v_u64m8_tu(vuint64m8_t vd, const uint64_t *rs1, } vfloat16mf4_t test_vluxei8_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint8mf8_t rs2, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei8_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint8mf4_t rs2, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei8_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint8mf2_t rs2, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei8_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint8m1_t rs2, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei8_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint8m2_t rs2, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vluxei8_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint8m4_t rs2, + const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_tum(vm, vd, rs1, rs2, vl); } @@ -651,37 +651,37 @@ vuint64m8_t test_vluxei8_v_u64m8_tum(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vluxei8_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint8mf8_t rs2, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei8_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint8mf4_t rs2, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei8_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint8mf2_t rs2, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei8_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint8m1_t rs2, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei8_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint8m2_t rs2, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vluxei8_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint8m4_t rs2, + const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_tumu(vm, vd, rs1, rs2, vl); } @@ -1001,37 +1001,37 @@ vuint64m8_t test_vluxei8_v_u64m8_tumu(vbool8_t vm, vuint64m8_t vd, } vfloat16mf4_t test_vluxei8_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, - const float16_t *rs1, vuint8mf8_t rs2, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxei8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2_t test_vluxei8_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, - const float16_t *rs1, vuint8mf4_t rs2, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1_t test_vluxei8_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, - const float16_t *rs1, vuint8mf2_t rs2, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m2_t test_vluxei8_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, - const float16_t *rs1, vuint8m1_t rs2, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m4_t test_vluxei8_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, - const float16_t *rs1, vuint8m2_t rs2, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m8_t test_vluxei8_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, - const float16_t *rs1, vuint8m4_t rs2, + const _Float16 *rs1, vuint8m4_t rs2, size_t vl) { return __riscv_vluxei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg2ei16.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg2ei16.c index 57f570509..14a2364f2 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg2ei16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg2ei16.c @@ -6,31 +6,31 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tu(vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tu(vd, rs1, rs2, vl); } @@ -277,32 +277,32 @@ vuint64m4x2_t test_vluxseg2ei16_v_u64m4x2_tu(vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tum(vm, vd, rs1, rs2, vl); } @@ -568,32 +568,32 @@ vuint64m4x2_t test_vluxseg2ei16_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -862,32 +862,32 @@ vuint64m4x2_t test_vluxseg2ei16_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei16_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei16_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei16_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg2ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei16_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg2ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei16_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m4_t rs2, size_t vl) { return __riscv_vluxseg2ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg2ei32.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg2ei32.c index 76c302e9a..b70114deb 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg2ei32.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg2ei32.c @@ -6,31 +6,31 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tu(vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tu(vd, rs1, rs2, vl); } @@ -267,32 +267,32 @@ vuint64m4x2_t test_vluxseg2ei32_v_u64m4x2_tu(vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tum(vm, vd, rs1, rs2, vl); } @@ -546,32 +546,32 @@ vuint64m4x2_t test_vluxseg2ei32_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -828,32 +828,32 @@ vuint64m4x2_t test_vluxseg2ei32_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei32_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei32_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg2ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei32_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg2ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei32_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg2ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei32_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m8_t rs2, size_t vl) { return __riscv_vluxseg2ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg2ei64.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg2ei64.c index 259165f03..3f599e3b2 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg2ei64.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg2ei64.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tu(vd, rs1, rs2, vl); } @@ -240,26 +240,26 @@ vuint64m4x2_t test_vluxseg2ei64_v_u64m4x2_tu(vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tum(vm, vd, rs1, rs2, vl); } @@ -489,26 +489,26 @@ vuint64m4x2_t test_vluxseg2ei64_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -741,26 +741,26 @@ vuint64m4x2_t test_vluxseg2ei64_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei64_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg2ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei64_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg2ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei64_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg2ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei64_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg2ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg2ei8.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg2ei8.c index 78e24b48d..c274860fa 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg2ei8.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg2ei8.c @@ -6,31 +6,31 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tu(vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tu(vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tu(vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tu(vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tu(vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tu(vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tu(vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tu(vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tu(vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tu(vd, rs1, rs2, vl); } @@ -277,32 +277,32 @@ vuint64m4x2_t test_vluxseg2ei8_v_u64m4x2_tu(vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tum(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tum(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tum(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tum(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tum(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tum(vm, vd, rs1, rs2, vl); } @@ -568,32 +568,32 @@ vuint64m4x2_t test_vluxseg2ei8_v_u64m4x2_tum(vbool16_t vm, vuint64m4x2_t vd, vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_tumu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_tumu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_tumu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_tumu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_tumu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -858,31 +858,31 @@ vuint64m4x2_t test_vluxseg2ei8_v_u64m4x2_tumu(vbool16_t vm, vuint64m4x2_t vd, } vfloat16mf4x2_t test_vluxseg2ei8_v_f16mf4x2_mu(vbool64_t vm, vfloat16mf4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg2ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x2_t test_vluxseg2ei8_v_f16mf2x2_mu(vbool32_t vm, vfloat16mf2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg2ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x2_t test_vluxseg2ei8_v_f16m1x2_mu(vbool16_t vm, vfloat16m1x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x2_t test_vluxseg2ei8_v_f16m2x2_mu(vbool8_t vm, vfloat16m2x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg2ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m4x2_t test_vluxseg2ei8_v_f16m4x2_mu(vbool4_t vm, vfloat16m4x2_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m2_t rs2, size_t vl) { return __riscv_vluxseg2ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg3ei16.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg3ei16.c index ead4f647d..3fc16564a 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg3ei16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg3ei16.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x3_t test_vluxseg3ei16_v_u64m2x3_tu(vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x3_t test_vluxseg3ei16_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -669,26 +669,26 @@ vuint64m2x3_t test_vluxseg3ei16_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei16_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei16_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei16_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg3ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei16_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg3ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg3ei32.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg3ei32.c index a37904b0c..c768c0599 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg3ei32.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg3ei32.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x3_t test_vluxseg3ei32_v_u64m2x3_tu(vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x3_t test_vluxseg3ei32_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -669,26 +669,26 @@ vuint64m2x3_t test_vluxseg3ei32_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei32_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei32_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg3ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei32_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg3ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei32_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg3ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg3ei64.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg3ei64.c index d7f08e550..0f3422e0b 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg3ei64.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg3ei64.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tu(vd, rs1, rs2, vl); } @@ -206,26 +206,26 @@ vuint64m2x3_t test_vluxseg3ei64_v_u64m2x3_tu(vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tum(vm, vd, rs1, rs2, vl); } @@ -419,26 +419,26 @@ vuint64m2x3_t test_vluxseg3ei64_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -635,26 +635,26 @@ vuint64m2x3_t test_vluxseg3ei64_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei64_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg3ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei64_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg3ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei64_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg3ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei64_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg3ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg3ei8.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg3ei8.c index 377d5e7ae..a6f8c513a 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg3ei8.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg3ei8.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tu(vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tu(vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tu(vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tu(vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tu(vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tu(vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tu(vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x3_t test_vluxseg3ei8_v_u64m2x3_tu(vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tum(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tum(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tum(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tum(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x3_t test_vluxseg3ei8_v_u64m2x3_tum(vbool32_t vm, vuint64m2x3_t vd, vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_tumu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_tumu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_tumu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_tumu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -665,25 +665,25 @@ vuint64m2x3_t test_vluxseg3ei8_v_u64m2x3_tumu(vbool32_t vm, vuint64m2x3_t vd, } vfloat16mf4x3_t test_vluxseg3ei8_v_f16mf4x3_mu(vbool64_t vm, vfloat16mf4x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg3ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x3_t test_vluxseg3ei8_v_f16mf2x3_mu(vbool32_t vm, vfloat16mf2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg3ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x3_t test_vluxseg3ei8_v_f16m1x3_mu(vbool16_t vm, vfloat16m1x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg3ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x3_t test_vluxseg3ei8_v_f16m2x3_mu(vbool8_t vm, vfloat16m2x3_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg3ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg4ei16.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg4ei16.c index c4102219a..71f592f7d 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg4ei16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg4ei16.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x4_t test_vluxseg4ei16_v_u64m2x4_tu(vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x4_t test_vluxseg4ei16_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -669,26 +669,26 @@ vuint64m2x4_t test_vluxseg4ei16_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei16_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei16_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei16_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg4ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei16_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m2_t rs2, size_t vl) { return __riscv_vluxseg4ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg4ei32.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg4ei32.c index 830b06d63..861da0183 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg4ei32.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg4ei32.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x4_t test_vluxseg4ei32_v_u64m2x4_tu(vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x4_t test_vluxseg4ei32_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -669,26 +669,26 @@ vuint64m2x4_t test_vluxseg4ei32_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei32_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei32_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg4ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei32_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg4ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei32_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m4_t rs2, size_t vl) { return __riscv_vluxseg4ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg4ei64.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg4ei64.c index ea8c7af09..2c1f18506 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg4ei64.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg4ei64.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tu(vd, rs1, rs2, vl); } @@ -206,26 +206,26 @@ vuint64m2x4_t test_vluxseg4ei64_v_u64m2x4_tu(vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tum(vm, vd, rs1, rs2, vl); } @@ -419,26 +419,26 @@ vuint64m2x4_t test_vluxseg4ei64_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -635,26 +635,26 @@ vuint64m2x4_t test_vluxseg4ei64_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei64_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg4ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei64_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg4ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei64_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg4ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei64_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m8_t rs2, size_t vl) { return __riscv_vluxseg4ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg4ei8.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg4ei8.c index 5b64a0d86..a04551aae 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg4ei8.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg4ei8.c @@ -6,25 +6,25 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tu(vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tu(vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tu(vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tu(vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tu(vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tu(vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tu(vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tu(vd, rs1, rs2, vl); } @@ -216,26 +216,26 @@ vuint64m2x4_t test_vluxseg4ei8_v_u64m2x4_tu(vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tum(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tum(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tum(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tum(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tum(vm, vd, rs1, rs2, vl); } @@ -441,26 +441,26 @@ vuint64m2x4_t test_vluxseg4ei8_v_u64m2x4_tum(vbool32_t vm, vuint64m2x4_t vd, vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_tumu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_tumu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_tumu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_tumu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -665,25 +665,25 @@ vuint64m2x4_t test_vluxseg4ei8_v_u64m2x4_tumu(vbool32_t vm, vuint64m2x4_t vd, } vfloat16mf4x4_t test_vluxseg4ei8_v_f16mf4x4_mu(vbool64_t vm, vfloat16mf4x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg4ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x4_t test_vluxseg4ei8_v_f16mf2x4_mu(vbool32_t vm, vfloat16mf2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg4ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x4_t test_vluxseg4ei8_v_f16m1x4_mu(vbool16_t vm, vfloat16m1x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg4ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m2x4_t test_vluxseg4ei8_v_f16m2x4_mu(vbool8_t vm, vfloat16m2x4_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8m1_t rs2, size_t vl) { return __riscv_vluxseg4ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg5ei16.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg5ei16.c index 57860eb38..9ad9aa83c 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg5ei16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg5ei16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x5_t test_vluxseg5ei16_v_u64m1x5_tu(vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x5_t test_vluxseg5ei16_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x5_t test_vluxseg5ei16_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei16_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei16_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei16_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg5ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg5ei32.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg5ei32.c index 956c3272a..4866e707c 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg5ei32.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg5ei32.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x5_t test_vluxseg5ei32_v_u64m1x5_tu(vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x5_t test_vluxseg5ei32_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x5_t test_vluxseg5ei32_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei32_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei32_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg5ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei32_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg5ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg5ei64.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg5ei64.c index 73f96ff86..2c179a01b 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg5ei64.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg5ei64.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x5_t test_vluxseg5ei64_v_u64m1x5_tu(vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x5_t test_vluxseg5ei64_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x5_t test_vluxseg5ei64_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei64_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg5ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei64_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg5ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei64_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg5ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg5ei8.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg5ei8.c index bab811d62..f518914cd 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg5ei8.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg5ei8.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tu(vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tu(vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tu(vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tu(vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tu(vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x5_t test_vluxseg5ei8_v_u64m1x5_tu(vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tum(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tum(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tum(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x5_t test_vluxseg5ei8_v_u64m1x5_tum(vbool64_t vm, vuint64m1x5_t vd, vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_tumu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_tumu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_tumu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -472,19 +472,19 @@ vuint64m1x5_t test_vluxseg5ei8_v_u64m1x5_tumu(vbool64_t vm, vuint64m1x5_t vd, } vfloat16mf4x5_t test_vluxseg5ei8_v_f16mf4x5_mu(vbool64_t vm, vfloat16mf4x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg5ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x5_t test_vluxseg5ei8_v_f16mf2x5_mu(vbool32_t vm, vfloat16mf2x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg5ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x5_t test_vluxseg5ei8_v_f16m1x5_mu(vbool16_t vm, vfloat16m1x5_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg5ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg6ei16.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg6ei16.c index dc02ba51a..ea7d22f4a 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg6ei16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg6ei16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x6_t test_vluxseg6ei16_v_u64m1x6_tu(vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x6_t test_vluxseg6ei16_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x6_t test_vluxseg6ei16_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei16_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei16_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei16_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg6ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg6ei32.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg6ei32.c index 7939f91fa..d1f3605aa 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg6ei32.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg6ei32.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x6_t test_vluxseg6ei32_v_u64m1x6_tu(vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x6_t test_vluxseg6ei32_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x6_t test_vluxseg6ei32_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei32_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei32_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg6ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei32_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg6ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg6ei64.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg6ei64.c index c33505159..d2d3d7427 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg6ei64.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg6ei64.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x6_t test_vluxseg6ei64_v_u64m1x6_tu(vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x6_t test_vluxseg6ei64_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x6_t test_vluxseg6ei64_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei64_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg6ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei64_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg6ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei64_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg6ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg6ei8.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg6ei8.c index eb6cec69d..741097f66 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg6ei8.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg6ei8.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tu(vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tu(vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tu(vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tu(vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tu(vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x6_t test_vluxseg6ei8_v_u64m1x6_tu(vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tum(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tum(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tum(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x6_t test_vluxseg6ei8_v_u64m1x6_tum(vbool64_t vm, vuint64m1x6_t vd, vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_tumu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_tumu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_tumu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -472,19 +472,19 @@ vuint64m1x6_t test_vluxseg6ei8_v_u64m1x6_tumu(vbool64_t vm, vuint64m1x6_t vd, } vfloat16mf4x6_t test_vluxseg6ei8_v_f16mf4x6_mu(vbool64_t vm, vfloat16mf4x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg6ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x6_t test_vluxseg6ei8_v_f16mf2x6_mu(vbool32_t vm, vfloat16mf2x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg6ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x6_t test_vluxseg6ei8_v_f16m1x6_mu(vbool16_t vm, vfloat16m1x6_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg6ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg7ei16.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg7ei16.c index 2f56182d7..a73443cc8 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg7ei16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg7ei16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x7_t test_vluxseg7ei16_v_u64m1x7_tu(vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x7_t test_vluxseg7ei16_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x7_t test_vluxseg7ei16_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei16_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei16_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei16_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg7ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg7ei32.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg7ei32.c index e2c8103c4..fbdbf42d1 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg7ei32.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg7ei32.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x7_t test_vluxseg7ei32_v_u64m1x7_tu(vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x7_t test_vluxseg7ei32_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x7_t test_vluxseg7ei32_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei32_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei32_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg7ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei32_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg7ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg7ei64.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg7ei64.c index d92a4510e..25816b288 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg7ei64.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg7ei64.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x7_t test_vluxseg7ei64_v_u64m1x7_tu(vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x7_t test_vluxseg7ei64_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x7_t test_vluxseg7ei64_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei64_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg7ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei64_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg7ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei64_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg7ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg7ei8.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg7ei8.c index 7489743d3..fd806647b 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg7ei8.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg7ei8.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tu(vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tu(vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tu(vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tu(vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tu(vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x7_t test_vluxseg7ei8_v_u64m1x7_tu(vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tum(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tum(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tum(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x7_t test_vluxseg7ei8_v_u64m1x7_tum(vbool64_t vm, vuint64m1x7_t vd, vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_tumu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_tumu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_tumu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -472,19 +472,19 @@ vuint64m1x7_t test_vluxseg7ei8_v_u64m1x7_tumu(vbool64_t vm, vuint64m1x7_t vd, } vfloat16mf4x7_t test_vluxseg7ei8_v_f16mf4x7_mu(vbool64_t vm, vfloat16mf4x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg7ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x7_t test_vluxseg7ei8_v_f16mf2x7_mu(vbool32_t vm, vfloat16mf2x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg7ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x7_t test_vluxseg7ei8_v_f16m1x7_mu(vbool16_t vm, vfloat16m1x7_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg7ei8_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg8ei16.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg8ei16.c index bc247ca1d..5ef0dd518 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg8ei16.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg8ei16.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x8_t test_vluxseg8ei16_v_u64m1x8_tu(vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x8_t test_vluxseg8ei16_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x8_t test_vluxseg8ei16_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei16_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei16_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei16_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei16_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint16m1_t rs2, size_t vl) { return __riscv_vluxseg8ei16_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg8ei32.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg8ei32.c index 1520b7189..7cd43c805 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg8ei32.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg8ei32.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x8_t test_vluxseg8ei32_v_u64m1x8_tu(vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x8_t test_vluxseg8ei32_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x8_t test_vluxseg8ei32_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei32_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei32_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m1_t rs2, size_t vl) { return __riscv_vluxseg8ei32_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei32_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint32m2_t rs2, size_t vl) { return __riscv_vluxseg8ei32_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg8ei64.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg8ei64.c index 465fd0ce1..fc19bc222 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg8ei64.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg8ei64.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x8_t test_vluxseg8ei64_v_u64m1x8_tu(vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x8_t test_vluxseg8ei64_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_tumu(vm, vd, rs1, rs2, vl); } @@ -476,20 +476,20 @@ vuint64m1x8_t test_vluxseg8ei64_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei64_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m1_t rs2, size_t vl) { return __riscv_vluxseg8ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei64_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m2_t rs2, size_t vl) { return __riscv_vluxseg8ei64_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei64_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint64m4_t rs2, size_t vl) { return __riscv_vluxseg8ei64_mu(vm, vd, rs1, rs2, vl); } diff --git a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg8ei8.c b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg8ei8.c index 3f160c31a..19b37a8ea 100644 --- a/auto-generated/policy_funcs/overloaded-api-testing/vluxseg8ei8.c +++ b/auto-generated/policy_funcs/overloaded-api-testing/vluxseg8ei8.c @@ -6,19 +6,19 @@ typedef float float32_t; typedef double float64_t; vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tu(vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tu(vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tu(vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tu(vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tu(vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tu(vd, rs1, rs2, vl); } @@ -155,20 +155,20 @@ vuint64m1x8_t test_vluxseg8ei8_v_u64m1x8_tu(vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tum(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tum(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tum(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tum(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tum(vm, vd, rs1, rs2, vl); } @@ -314,20 +314,20 @@ vuint64m1x8_t test_vluxseg8ei8_v_u64m1x8_tum(vbool64_t vm, vuint64m1x8_t vd, vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_tumu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_tumu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tumu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_tumu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_tumu(vm, vd, rs1, rs2, vl); } @@ -472,19 +472,19 @@ vuint64m1x8_t test_vluxseg8ei8_v_u64m1x8_tumu(vbool64_t vm, vuint64m1x8_t vd, } vfloat16mf4x8_t test_vluxseg8ei8_v_f16mf4x8_mu(vbool64_t vm, vfloat16mf4x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf8_t rs2, size_t vl) { return __riscv_vluxseg8ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16mf2x8_t test_vluxseg8ei8_v_f16mf2x8_mu(vbool32_t vm, vfloat16mf2x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf4_t rs2, size_t vl) { return __riscv_vluxseg8ei8_mu(vm, vd, rs1, rs2, vl); } vfloat16m1x8_t test_vluxseg8ei8_v_f16m1x8_mu(vbool16_t vm, vfloat16m1x8_t vd, - const float16_t *rs1, + const _Float16 *rs1, vuint8mf2_t rs2, size_t vl) { return __riscv_vluxseg8ei8_mu(vm, vd, rs1, rs2, vl); }